Go on avni.sh

REST API Requests in Go

Fri, 15 Sep 2023 00:00:00 +0000

What is REST?

REST (REpresentational State Transfer) is an architectural style for designing and developing APIs that could be used for client and server interactions.

REST defines 6 architectural constraints for APIs:

Uniform interface: API requests for a resource should look the same irrespective of its origin client. The Uniform Resource Identifier (URI) allocated to resources should be unique.
Client-server: Changes on the client side should not affect the server and vice-versa.
Stateless: The API request should contain all the resources required to process it. The server should not store any details related to client requests.
Cacheable: API Responses could be cached on the client or server side.
Layered system: Neither the client nor the server should have information regarding the number of intermediate layers during communication.
Code on demand (optional): When required, code snippets sent through API responses should be executable on demand.

APIs that comply with REST architecture constraints are called RESTful APIs.

REST Requests

A REST request comprises of:

HTTP Verb: Specifies the type of operation to be performed on resource/s like creation, fetch, updation, and deletion.
Header: Contains the information about the request like its datatype (text/html, text/plain, application/json, etc.), credentials, proxy server address, etc.
Path: Path to the resource (URI)
Body: Input data for the operation.

HTTP Verbs

GET, POST, PUT, and DELETE are common HTTP verbs available in RESTful APIs.

Note: To follow this tutorial you need to head over to crudcrud.com to get a new API endpoint.

The net/http Go package provides all the necessary utilities for implementing REST clients and servers.

`POST`

A POST request is performed to create resources.

If we have to perform a POST request on the API endpoint provided by crudcrud.com we have to pass the resource (to be created) as a JSON payload in the request’s body.

package main

import (
   "fmt"
   "net/http"
   "encoding/json"
   "bytes"
   "io/ioutil"
)

func main() {
	// Replace with the API ID provided by crudcrud.com
	apiID := "XXXXXX"

	// HTTP endpoint with path of resource (vehicles)
	createResourceURL := fmt.Sprintf("https://crudcrud.com/api/%s/vehicles",
									apiID)

	// JSON payload containing resource information
	requestBody, _ := json.Marshal(map[string]string{
		"color": "White",
		"license": "ABC123",
		"numWheels": "4",
		"type": "Car",
	})

	// Converting request body into bytes buffer
	requestBodyBytes := bytes.NewBuffer(requestBody)

	// Creating a POST request on createResourceURL
	request, err := http.NewRequest("POST", createResourceURL, requestBodyBytes)
	if err != nil {
		panic(err)
	}

	// Adding application/json as payload type 
	request.Header.Add("Content-Type", "application/json")

	client := &http.Client{}

	// Performing POST request
	response, err := client.Do(request)
	if err != nil {
		panic(err)
	}

	defer response.Body.Close()

	// Reading the response to the request
	responseBody, err := ioutil.ReadAll(response.Body)
	if err != nil {
		fmt.Println("Error received in response:",err)
	}

	responseBodyString := string(responseBody)
	fmt.Println(responseBodyString)
}

// Output
// {"color":"White","license":"ABC123","numWheels":"4","type":"Car",
// "_id":"6501480bb987ad03e8769e4}

To check the resource on the server side you can click on the “Check Endpoint Information” button on the crudcrud.com page. A new REST resource named vehicles would have been created.

`GET`

To fetch all vehicles resources created by the POST request we will perform a GET request on the same API endpoint.

package main

import (
   "fmt"
   "net/http"
   "io/ioutil"
   "encoding/json"
)

type Vehicle struct{
	Id          string `json:"_id"`
	Color       string
	License     string
	NumWheels   string
	VehicleType string
}

func main() {
	// Replace this with the API ID provided by crudcrud.com
	apiID := "XXXXXX"

	// HTTP endpoint with the path of the resource (vehicles)
	fetchResourceURL := fmt.Sprintf("https://crudcrud.com/api/%s/vehicles", 
									apiID)

	// Performing GET request
	response, err := http.Get(fetchResourceURL)
	if err != nil {
		panic(err)
	}

	defer response.Body.Close()

	// Reading the response to the request
	responseBody, err := ioutil.ReadAll(response.Body)
	if err != nil {
		fmt.Println("Error received in response:",err)
	}

	// Marshalling the response of API into a list of type Vehicle
	var vehicles []Vehicle
	json.Unmarshal(responseBody, &vehicles)
	
	for _, veh := range vehicles{
		fmt.Println("Vehicle Resource ID:", veh.Id)
		fmt.Println("Color:", veh.Color)
		fmt.Println("License:", veh.License)
		fmt.Println("NumWheels:", veh.NumWheels)
		fmt.Println("Type:", veh.VehicleType)
		fmt.Println()
	}

}

// Output
// Vehicle Resource ID: 65014c0ab987ad03e8769e5c
// Color: Black
// License: XYZ435
// NumWheels: 4
// Type: Car
//
// Vehicle Resource ID: 65014c1cb987ad03e8769e5d
// Color: White
// License: ABC123
// NumWheels: 4
// Type: Car
//
// Vehicle Resource ID: 65014c59b987ad03e8769e5e
// Color: Red
// License: IJK546
// NumWheels: 2
// Type: Motorcycle

We can also fetch specific resources by specifying their _id in URI.

package main

import (
   "fmt"
   "net/http"
   "io/ioutil"
   "encoding/json"
)

type Vehicle struct{
	Id          string `json:"_id"`
	Color       string
	License     string
	NumWheels   string
	VehicleType string
}

func main() {
	// Replace this API ID with the one provided by crudcrud.com
	apiID := "XXXXXX"

	// Replace this with the ID of the resource you want to fetch
	vehicleResourceID := "65014c59b987ad03e8769e5e"

	// HTTP endpoint with the path of the resource (vehicles)
	fetchResourceURL := fmt.Sprintf("https://crudcrud.com/api/%s/vehicles/%s",	
							apiID, vehicleResourceID)

	// Performing GET request
	response, err := http.Get(fetchResourceURL)
	if err != nil {
		panic(err)
	}

	defer response.Body.Close()

	// Reading the response to the request
	responseBody, err := ioutil.ReadAll(response.Body)
	if err != nil {
		fmt.Println("Error received in response:",err)
	}

	// Unmarshalling the response of API into a list of type Vehicle
	var veh Vehicle
	json.Unmarshal(responseBody, &veh)

	fmt.Println("Vehicle Resource ID:", veh.Id)
	fmt.Println("Color:", veh.Color)
	fmt.Println("License:", veh.License)
	fmt.Println("NumWheels:", veh.NumWheels)
	fmt.Println("Type:", veh.VehicleType)
}

// Output
// Vehicle Resource ID: 65014c59b987ad03e8769e5e
// Color: Red
// License: IJK546
// NumWheels: 2
// Type: Motorcycle

`PUT`

To update a resource we perform a PUT request.

package main

import (
   "fmt"
   "net/http"
   "encoding/json"
   "bytes"
   "io/ioutil"
)

func main() {
	// Replace this API ID with the one provided by crudcrud.com
	apiID := "XXXXXX"

	vehicleResourceID := "65014c0ab987ad03e8769e5c"

	// HTTP endpoint with path (vehicle) of the resource
	updateResourceURL := fmt.Sprintf("https://crudcrud.com/api/%s/vehicles/%s",	
							apiID, vehicleResourceID)

	// JSON payload as bytes
	requestBody, _ := json.Marshal(map[string]string{
		"color": "Black",
		"license": "XYZ435",
		"numWheels": "2",
		"vehicleType": "Motorcycle",
	})

	// Converting request body into bytes buffer
	requestBodyBytes := bytes.NewBuffer(requestBody)

	// Creating a PUT request on updateResourceURL
	request, err := http.NewRequest("PUT", updateResourceURL, requestBodyBytes)
	if err != nil {
		panic(err)
	}

	// Adding application/json as payload type 
	request.Header.Add("Content-Type", "application/json")

	client := &http.Client{}

	// Performing PUT request
	response, err := client.Do(request)
	if err != nil {
		panic(err)
	}

	defer response.Body.Close()

	// Verifying changes by fetching the details of the resource
	// Performing GET request
	responseGet, err := http.Get(updateResourceURL)
	if err != nil {
		panic(err)
	}

	defer responseGet.Body.Close()

	// Reading the response to the request
	responseBody, err := ioutil.ReadAll(responseGet.Body)
	if err != nil {
		fmt.Println("Error received in response:",err)
	}

	fmt.Println("Updated Resource:",string(responseBody))
}

// Output
// Updated Resource: {"_id":"65014c0ab987ad03e8769e5c","color":"Black",
// "license":"XYZ435","numWheels":"2","vehicleType":"Motorcycle"}

`DELETE`

The DELETE verb is used for resource deletion requests.

package main

import (
   "fmt"
   "net/http"
   "io/ioutil"
)

func main() {
	// Replace this API ID with the one provided by crudcrud.com
	apiID := "XXXXXX"

	vehicleResourceID := "65014c0ab987ad03e8769e5c"

	// HTTP endpoint with path (vehicle) of the resource
	deleteResourceURL := fmt.Sprintf("https://crudcrud.com/api/%s/vehicles/%s", 
							apiID, vehicleResourceID)

	// Creating a DELETE request on deleteResourceURL
	request, err := http.NewRequest("DELETE", deleteResourceURL, nil)
	if err != nil {
		panic(err)
	}

	// Adding application/json as payload type 
	request.Header.Add("Content-Type", "application/json")

	client := &http.Client{}

	// Performing DELETE request
	response, err := client.Do(request)
	if err != nil {
		panic(err)
	}

	defer response.Body.Close()

	// Performing GET request
	responseGet, err := http.Get(deleteResourceURL)
	if err != nil {
		panic(err)
	}

	defer responseGet.Body.Close()

	// Reading the response to the request
	responseBody, err := ioutil.ReadAll(responseGet.Body)
	if err != nil {
		fmt.Println("Error received in response:",err)
	}

	fmt.Println("Deleted Resource:",string(responseBody))
}

// Output
// Deleted Resource: {"type":"https://tools.ietf.org/html/rfc7231#section-6.5.4",
// "title":"Not Found","status":404,"traceId":"0HMTFDGO4V3QF:00000001"}

Resources

REST API Tutorial
What is REST?
REST Architectural Constraints
net/http Go Package
HTTP Verbs in net/http package

Concurrency in Go

Tue, 12 Sep 2023 00:00:00 +0000

We can make a program concurrent if we can split it as multiple independent tasks executed at the same time.

In concurrency, we execute different portions of a program at the same time (on single or multiple CPU threads) whereas in parallelism a singular task (or subtasks) is executed parallelly on multiple CPU threads.

Concurrency is about dealing with lots of things at once. Parallelism is about doing lots of things at once.

Rob Pike, Co-Creator of Go

Goroutines

By adding the go keyword before a statement we can start a new goroutine. It will create a lightweight execution thread to execute the statement concurrently with the succeeding tasks in its parent function.

The program will end once the main goroutine is finished irrespective of the current state of other goroutines.

// Example of a non-concurrent program

package main

import (
        "fmt"
        "time"
)

func testFunc() {
        for j:=0;j<3;j++{
                fmt.Println("Hello from testfunc")
        }
        time.Sleep(2*time.Second)
}

func main() {
        testFunc()
        for i:=0;i<3;i++{
                fmt.Println("Hello from main")
                time.Sleep(2*time.Second)
        }
}

// Output
// Hello from testfunc
// Hello from testfunc
// Hello from testfunc
// Hello from main
// Hello from main
// Hello from main

The output of this program will be three statements from testFunc() functions followed by three statements from the main() function.

But, if we add the go keyword before testFunc(), we can create a new goroutine that will execute the testFunc() function concurrently with the statements in main().

package main

import (
        "fmt"
        "time"
)

func testFunc() {
        for j:=0;j<3;j++{
                fmt.Println("Hello from testfunc")
        }
        time.Sleep(2*time.Second)
}

func main() {
        go testFunc()
        for i:=0;i<3;i++{
                fmt.Println("Hello from main")
                time.Sleep(2*time.Second)
        }
}

// Output
// Hello from main
// Hello from testfunc
// Hello from testfunc
// Hello from testfunc
// Hello from main
// Hello from main

Channels

To send and receive values between Goroutines we have channels.

Channels are declared using the make(chan ) function with the datatype of the transmitted value, for example, make(chan string) will create a channel that could be used to send and receive string values.

chan<- string denotes a send-only channel and <-chan string denotes a receive-only channel for string values.

To iterate over the values received on a channel we can define a for loop with range like in the program below.

package main

import (
        "fmt"
        "time"
        "math/rand"
)

// Sends random integer on randomVal channel every 2 seconds
func getRandomValue(randomVal chan<- int, numValues int){
        for i:=0;i<numValues;i++{
                value := rand.Int()
                fmt.Println("getRandomValue(): Sent Random Integer", value)

                // Send a value to randomVal channel
                randomVal <- value

                // 2 seconds interval to ensure that the receiver gets enough time
                time.Sleep(time.Second*2)
        }
        close(randomVal)
}

// Listens to channel randomVal and prints received values on the terminal
func receiveRandomValue(randomVal <-chan int){

        // Loops over values received in channel
        for value := range randomVal{
                fmt.Println("recieveRandomValue(): Received Random Integer", value)
        }
}

func main() {
        randomValueChannel := make(chan int)

        go getRandomValue(randomValueChannel, 5)

        go receiveRandomValue(randomValueChannel)

        // To ensure that the main goroutine doesn't end 
        // before the other two goroutines
        time.Sleep(time.Second*10)
}

// Output
// getRandomValue(): Sent Random Integer 7680245871766720879
// recieveRandomValue(): Received Random Integer 7680245871766720879
// getRandomValue(): Sent Random Integer 1813843778283051521
// recieveRandomValue(): Received Random Integer 1813843778283051521
// getRandomValue(): Sent Random Integer 3359384099851901129
// recieveRandomValue(): Received Random Integer 3359384099851901129
// getRandomValue(): Sent Random Integer 3707965584748576540
// recieveRandomValue(): Received Random Integer 3707965584748576540
// getRandomValue(): Sent Random Integer 282243786570954167
// recieveRandomValue(): Received Random Integer 282243786570954167

A Go program finishes execution whenever the main goroutine is completed ignoring the current progress of other goroutines. To prevent this we can use a channel to flag completion of a goroutine.

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func getRandomInt(doneFlag chan bool){
	fmt.Println("Goroutine for getRandomInt() started")
	fmt.Println("Some random integer: ", rand.Int())
	time.Sleep(time.Second*5)

	// Will send value to the channel
	// once the function is finished
	doneFlag<-true
}

func main(){
	done := make(chan bool)

	go getRandomInt(done)

	// Main Goroutine will wait to receive a value on this channel
	<-done

	fmt.Println("Main Goroutine has ended")
}

// Output
// Goroutine for getRandomInt() started
// Some random integer:  4571662314887367842
// Main Goroutine has ended

If we ran this program without <-done the main goroutine would’ve ended the program preemptively and its output would be

Main Goroutine has ended

Buffering

A channel won’t send values unless there is another channel ready to receive those values. But Buffered Channels allow a certain amount of values to be sent without a corresponding receiver for those values.

package main

import "fmt"

func main() {
	exampleBufferedChan := make(chan string, 3)

	// Sending values to the buffered channel
	exampleBufferedChan<-"c"
	exampleBufferedChan<-"b"
	exampleBufferedChan<-"a"

	// Receiving values from the buffered channel
	fmt.Println("Value 1 from exampleBufferedChan:",<-exampleBufferedChan)
	fmt.Println("Value 2 from exampleBufferedChan:",<-exampleBufferedChan)
	fmt.Println("Value 3 from exampleBufferedChan:",<-exampleBufferedChan)
}

// Output
// Value 1 from exampleBufferedChan: c
// Value 2 from exampleBufferedChan: b
// Value 3 from exampleBufferedChan: a

The values from the channel will be received in the same order as they were sent.

Select

The select keyword is used to wait for values on multiple channels simultaneously. Its syntax is similar to a switch.

select executes the first channel to receive value in case statements. If multiple channels are ready with values then one of them is selected at random.

package main

import (
	"fmt"
	"time"
	"math/rand"
)

func randomValueGenerator(randomValueChannel chan<- int){
	time.Sleep(time.Second*5)
	randomValueChannel <- rand.Int()
}

func main(){
	channel1 := make(chan int, 1)
	channel2 := make(chan int, 1)

	go randomValueGenerator(channel1)
	randomValueGenerator(channel2)

	// Wait on channel1 and channel2 to receive values	
	select{
		case message1 := <- channel1:
			fmt.Println("Received value in channel1:", message1)
		case message2 := <- channel2:
			fmt.Println("Received value in channel2:", message2)
	}
}

// Output
// Received value in channel2: 1923060859381349025

I recommend executing this program multiple times as channel1 and channel2 will receive values at the same time and the output will be chosen at random by select.

Timeouts using `time.After()`

The time.After() function returns a value after the time specified in its parameter. It could be used as a timeout case in select statements.

package main

import (
	"fmt"
	"time"
)

func sendOnChannel(doneFlag chan<- bool){
	// It will take at least 5 seconds for this function to finish
	time.Sleep(time.Second*5)
	doneFlag<-true
}

func main(){
	channel1 := make(chan bool)
	channel2 := make(chan bool)

	go sendOnChannel(channel1)
	go sendOnChannel(channel2)

	select{
	case <-channel1:
		fmt.Println("Channel 1 has responded")
	case <-channel2:
		fmt.Println("Channel 2 has responded")

	// Added a 2 seconds timeout in the select statement
	case <-time.After(time.Second*2):
		fmt.Println("You've hit a timeout")
	}
}

// Output
// You've hit a timeout

Non-Blocking Channel Operations with `default`

A default statement is defined in select to avoid blocking from unbuffered channels.

package main

import (
	"fmt"
)

func main(){
	channel1 := make(chan bool)

	select{
	case <-channel1:
		fmt.Println("Something received on channel1")

	// Since there is no value received on channel1
	// the default case will be executed
	default:
		fmt.Println("This is default statement")
		fmt.Println("No value was received on channel1")
	}
}

// Output
// This is default statement
// No value was received on channel1

Closing Channels

We can close() a channel to stop it from accepting further values.

package main

import (
	"fmt"
)

func main() {
	valueChannel := make(chan int)

	go func(){
		for i:=0;i<5;i++{
			fmt.Println("Sending",i,"to channel valueChannel")
			valueChannel <- i
		}
		
		// Closing valueChannel to stop it from receiving further values
		close(valueChannel)
	}()

	go func(){
		for{
			value, openFlag := <- valueChannel
			if !openFlag{
				fmt.Println("valueChannel is closed")
				break
			}
			fmt.Println("Received value:", value)
		}
	}()

	<-valueChannel
	fmt.Println("All values received")
	fmt.Println("Main Goroutine finished")
}

// Output
// Sending 0 to channel valueChannel
// Sending 1 to channel valueChannel
// Sending 2 to channel valueChannel
// Received value: 1
// Received value: 2
// Sending 3 to channel valueChannel
// Sending 4 to channel valueChannel
// Received value: 3
// Received value: 4
// valueChannel is closed
// All values received
// Main Goroutine finished

WaitGroups

By default a Go program is finished when the main Goroutine is completed, We can add statements that wait for receiving over a channel like <-done once all goroutines are finished.

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func fastRoutine(done chan bool)(int){
	// It will take at least 2 seconds to execute this function
	fmt.Println("Fast Routine started")
	time.Sleep(time.Second*2)
	done <- true
	return rand.Int()
}

func slowRoutine(done chan bool)(int){
	// It will take at least 5 seconds to execute this function
	fmt.Println("Slow Routine started")
	time.Sleep(time.Second*5)
	done <- true
	return rand.Int()
}

func main(){
	done := make(chan bool)
	done2 := make(chan bool)

	go func(){
		fastRandomVal := fastRoutine(done)
		fmt.Println("Value received from fast routine:", fastRandomVal)
	}()

	go func(){
		slowRandomVal := slowRoutine(done2)
		fmt.Println("Value received from slow routine:", slowRandomVal)
	}()

	<-done
	<-done2
}

// Output
// Slow Routine started
// Fast Routine started
// Value received from fast routine: 1556543771289280615
// Value received from slow routine: 2312691093026658070

But sync.WaitGroup provides a much more elegant way to monitor multiple Goroutines at once.

package main

import (
	"fmt"
	"sync"
	"math/rand"
	"time"
)

func fastRoutine()(int){
	fmt.Println("Fast Routine started")
	time.Sleep(time.Second*2)
	return rand.Int()
}

func slowRoutine()(int){
	fmt.Println("Slow Routine started")
	time.Sleep(time.Second*5)
	return rand.Int()
}

func main(){
	// Created a WaitGroup
	var wg sync.WaitGroup

	// Incrementing WaitGroup counter by 1
	wg.Add(1)
	go func(){
		// Decrement WaitGroup counter by 1 
		// after the goroutine is finished
		defer wg.Done()
		fastRandomVal := fastRoutine()
		fmt.Println("Value received from fast routine:", fastRandomVal)
	}()

	wg.Add(1)
	go func(){
		defer wg.Done()
		slowRandomVal := slowRoutine()
		fmt.Println("Value received from slow routine:", slowRandomVal)
	}()

	// Wait for the WaitGroup counter to reach 0
	wg.Wait()
}

// Output
// Slow Routine started
// Fast Routine started
// Value received from fast routine: 4966166931659874487
// Value received from slow routine: 439978995889306642

WaitGroup starts a counter at 0 and a delta (int value) is added to it using the Add() method. The Done() method decrements the counter by 1 and the Wait() method waits for the counter to reach 0 and moves to the next statements in the program.

Resources

Concurrency vs Parallelism
Concurrency is not Parallelism
[Slides] Concurrency is not Parallelism
channels
WaitGroup

File Handling in Go

Tue, 27 Jun 2023 00:00:00 +0000

Reading and writing files is one of the most common tasks in programming projects. Using this skill we can store data persistently and decrease the memory consumption of our program.

Paths

The path/filepath package provides filepath.Join() function to create filesystem paths for files and directories. The same could also be achieved with string concatenation in Go but it won’t be interoperable between different operating systems (Linux uses the forward slash (/) for separators in the path whereas Windows uses the backward slash (\)).

Other functions provided by the path/filepath package:

filepath.Dir(): Returns the directory from the path (excluding filename).
filepath.Base(): Returns the filename from the path (excluding parent directories).
filepath.Ext(): Returns the extension of the file.
filepath.IsAbs(): Returns true if the filepath is an absolute path otherwise false.
filepath.Rel(): Returns relative path between its two argument paths.

package main

import (
	"fmt"
	"path/filepath"
)

func main() {
	exampleFile := filepath.Join("/app", "file_handling.go")
	fmt.Println("Example File Path:", exampleFile)
	fmt.Println("Filename:", filepath.Base(exampleFile))
	fmt.Println("Directory:", filepath.Dir(exampleFile))
	fmt.Println("Extension in Filename:", filepath.Ext(exampleFile))
	fmt.Println("Is exampleFile path absolute?:", filepath.IsAbs(exampleFile))

	value, err := filepath.Rel("/tmp", exampleFile)
	if err!=nil {
		panic(err)
	} else {
		fmt.Println("Relative path between /tmp and exampleFile will be:", 
				value)
	}
}

// Output
// Example File Path: /app/file_handling.go
// Filename: file_handling.go
// Directory: /app
// Extension in Filename: .go
// Is exampleFile path absolute?: true
// Relative path between /tmp and exampleFile will be: ../app/file_handling.go

`defer` Keyword

When a file is opened by a program its contents are loaded on the system memory. That’s why it is crucial to close the file and release the occupied memory. This will also prevent data corruption on the file.

Any statement in Go prefixed with defer keyword will be executed at the end of the parent function. These statements are generally used for cleanup tasks.

package main

import "fmt"

func testFunc() {
	defer fmt.Println("This will be executed after testFunc() has ended")
	fmt.Println("This is the last statement in testFunc()")
}

func main() {
	defer fmt.Println("This will be executed after main() has ended")
	testFunc()
	fmt.Println("Last statement in main()")
}

// Output
// This is the last statement in testFunc()
// This will be executed after testFunc() has ended
// Last statement in main()
// This will be executed after main() has ended

We can define the functions for closing files & perform other resource cleanup, then call them with defer keyword to ensure they are executed after our program has finished. The statements will be executed in the reverse order of their declaration.

Managing Directories

The os package in Go provides functions analogous to common Linux/Windows commands used for managing directories.

os.Mkdir(): Similar to the mkdir Linux command, it creates the directory given the filepath in string and the octal notation of directory permissions (like 0755).
os.MkdirAll(): Creates the complete hierarchy of directories similar to the mkdir command executed with --parents or -p flag.
os.RemoveAll(): Removes directory (including subfolders and files).
os.Getwd(): Returns the present working directory similar to the pwd command.
os.Chdir(): Changes present working directory. Same as the cd command.
os.ReadDir(): ls command in Linux lists the contents of the current directory, os.ReadDir() will do the same for the directory path passed as the argument. A for loop has to be defined on the slice returned by the function to access each file/directory with its name.

package main

import (
	"fmt"
	"os"
)

func removeDir(dirPath string) {
	os.RemoveAll(dirPath)
	fmt.Println(dirPath, "removed")
}

func getPWD() {
	pwd, err := os.Getwd()
	if err!=nil {
		panic(err)
	}
	fmt.Println("Present Working Directory is:", pwd)
}

func main() {
	fmt.Println("Creating temp directory")
	os.Mkdir("temp", 0755)

	fmt.Println("Creating temp2/temp3/testDir directory hierarchy")
	os.MkdirAll("temp2/temp3/testDir", 0755)
	os.Mkdir("temp2/temp4", 0755)
	os.Mkdir("temp2/temp5", 0755)

	// This will be executed after the main() function is finished
	defer removeDir("temp")
	defer removeDir("temp2")

	val, err := os.ReadDir("temp2")
	if err!=nil {
		panic(err)
	} else {
		fmt.Println("Contents of temp2 directory:")
		for _, file := range val {
			fmt.Print("\t",file.Name())
		}
		fmt.Print("\n")
	}
	
	getPWD()

	fmt.Println("Moving one level up")
	os.Chdir("../")
	getPWD()

	fmt.Println("Moving back to /app directory")
	os.Chdir("/app")
	getPWD()
}

// Output
// Creating temp directory
// Creating temp2/temp3/testDir directory hierarchy
// Contents of temp2 directory:
//         temp3   temp4   temp5
// Present Working Directory is: /app
// Moving one level up
// Present Working Directory is: /
// Moving back to /app directory
// Present Working Directory is: /app
// temp2 removed
// temp removed

Reading from a File

The os.ReadFile() function will load the entire content of a file into the system memory. If we want to save memory or read specific portions of a file we can use os.Open() function. It returns an instance of os.File struct that could be used for navigating the file in read-only mode.

The os.Seek() method will offset all read and write operations to a specific location in an os.File instance. For example exampleFile.Seek(10, 0) will increase the offset by 10 bytes. Hence, all the read and write operations performed on the exampleFile will skip the first 10 bytes. The second argument in os.Seek() signifies the origin relative to the offset i.e.

exampleFile.Seek(10, 0): 10 bytes from the start of the file
exampleFile.Seek(10, 1): 10 bytes from the current offset location
exampleFile.Seek(10, 2): 10 bytes from the end of the file

exampleFile.Seek(0, 0) will reset the offset to 0 (start of the file).

The os.Read() method is used to read the contents of a file in a byte slice. It returns the number of bytes read as a value. In the following example, we will perform read operations on example.txt.

$ cat example.txt
Hello, World
42 is the meaning of life, the universe, and everything

package main

import (
	"fmt"
	"os"
)

func main() {
	fmt.Println("Reading the complete example.txt")
	exampleFile, err := os.ReadFile("example.txt")
	if err!=nil {
		panic(err)
	} else {
		fmt.Println("Content from example.txt:")
		// Converting the byte slice returned by ReadFile to string
		fmt.Println(string(exampleFile))
		fmt.Println()
	}

	exampleFile2, err := os.Open("example.txt")
	if err!=nil {
		panic(err)
	}

	defer exampleFile2.Close()

	// Offsetting operations 13 bytes from the start
	exampleFile2.Seek(13, 0)

	byteArr := make([]byte, 17)
	numBytes, err := exampleFile2.Read(byteArr)
	if err!=nil {
		panic(err)
	}
	fmt.Println("Bytes read from exampleFile2:", numBytes)
	fmt.Printf("%v\n", string(byteArr[:numBytes]))
}

// Output
// Reading the complete example.txt
// Content from example.txt:
// Hello, World
// 42 is the meaning of life, the universe, and everything
// 
// Bytes read from exampleFile2: 17
// 42 is the meaning

Writing to a File

The os.Create() function will create a file or directory from the string path passed as its argument.

Similar to os.ReadFile(), the os.WriteFile() function will write the contents of a byte slice to the given file. It will also create the file if it doesn’t exist. To perform more granular writes we have os.Write() method.

To open a file for read-write operations we have to use os.OpenFile() instead of os.Open(), with os.O_RDWR as its argument. The changes written to the file by the program will not reflect on the system storage until the os.Sync() method is called.

package main

import (
	"fmt"
	"os"
)

func readFile(filepath string) {
	fmt.Println("Reading the contents of", filepath, ":")
	byteSlice, err := os.ReadFile(filepath)
	if err!=nil {
		panic(err)
	}
	fmt.Println(string(byteSlice))
}

func main() {
	fmt.Println("Writing to hello.txt")
	byteSlice := []byte("Hello from Go program\n")
	err := os.WriteFile("hello.txt", byteSlice, 0755)
	if err!=nil {
		panic(err)
	}
	fmt.Println("Write successful")

	defer os.Remove("hello.txt")

	readFile("hello.txt")

	helloFile, err := os.OpenFile("hello.txt", os.O_RDWR, 0755)
	if err!=nil {
		panic(err)
	}

	defer helloFile.Close()

	// Moving offset to the end of file
	_, err = helloFile.Seek(0, 2)
	if err!=nil {
		panic(err)
	}

	byteSliceWrite := "Hey from WriteFile"
	_, err = helloFile.WriteString(byteSliceWrite)
	if err!=nil {
		panic(err)
	}

	readFile("hello.txt")

	// Syncing changes between memory and storage
	helloFile.Sync()
}

// Output
// Writing to hello.txt
// Write successful
// Reading the contents of hello.txt :
// Hello from Go program
//
// Reading the contents of hello.txt :
// Hello from Go program
// Hey from WriteFile

Handling Common Filetypes

JSON, YAML, and XML are one of the most common file types for configuration, test results, and other structured data storage.

JSON

Encoding JSON

Encoding is the process of converting data into a specific format. To encode data into JSON format we have to use the encoding/json package.

The json.Marshal() function returns the JSON encoding for the struct instance passed as its argument. The fields in struct need to have their first character capitalized.

The Marshal-ed JSON could be written to file with the help of os.OpenFile() and os.Write() functions.

package main

import (
	"fmt"
	"encoding/json"
	"os"
)

type Vehicle struct {
	Name string
	Color string
	NumWheels int
}

func main() {
	v := Vehicle{Name: "Nissan GTR", Color: "Grey", NumWheels: 4}
	fmt.Println("Vehicle instance:", v)

	jsonData, err := json.Marshal(v)
	if err!=nil{
		panic(err)
	}
	fmt.Println("Vehicle JSON:\n", string(jsonData))

	file, err := os.OpenFile("vehicle.json", os.O_CREATE|os.O_RDWR, 0755)
	if err!=nil{
		panic(err)
	}
	
	defer file.Close()

	file.Write(jsonData)
	file.Sync()
}

// Output
// Vehicle instance: {Nissan GTR Grey 4}
// Vehicle JSON:
//  {"Name":"Nissan GTR","Color":"Grey","NumWheels":4}

$ cat vehicle.json 
{"Name":"Nissan GTR","Color":"Grey","NumWheels":4}

Decoding JSON

Decoding is the reverse of encoding, we take data from a specified format and convert it to its original form. The json Go package provides json.Unmarshal() function for decoding JSON into a struct.

package main

import (
	"fmt"
	"encoding/json"
	"os"
)

type Vehicle struct {
	Name string
	Color string
	NumWheels int
}

func main() {
	var v Vehicle

	jsonFile, err := os.ReadFile("vehicle.json")
	if err!=nil {
		panic(err)
	}

	defer jsonFile.Close()

	err = json.Unmarshal(jsonFile, &v)
	if err!=nil {
		panic(err)
	}
	fmt.Println("Struct Instance from JSON:", v)
}

// Output
// Struct Instance from JSON: {Nissan GTR Grey 4}

YAML

Similar to the json package, gopkg.in/yaml also provides yaml.Marshal() and yaml.Unmarshal() functions for encoding and decoding data into YAML respectively.

Before using the gopkg.in/yaml package we have to install it with the go get command.

go get gopkg.in/yaml.v2

package main

import (
	"fmt"
	"gopkg.in/yaml.v2"
	"os"
)

type VehicleUses struct {
	F1SafetyCar bool
}

type Vehicle struct {
	Name string
	Color string
	NumWheels int
	Uses VehicleUses
}

func main() {
	// Writing an instance of Vehicle to vehicle.yaml
	v := Vehicle{
	Name:"Aston Martin Vantage", 
	Color: "green", 
	NumWheels:4, 
	Uses:VehicleUses{F1SafetyCar: true}
	}

	fmt.Println("Vehicle Instance:", v)

	yamlData, err := yaml.Marshal(&v)
	if err!=nil {
		panic(err)
	}
	fmt.Println("Vehicle in YAML format:")
	fmt.Println(string(yamlData))

	yamlFile, err := os.OpenFile("vehicle.yaml", os.O_CREATE|os.O_RDWR, 0755)
	if err!=nil{
		panic(err)
	}

	defer yamlFile.Close()
	defer os.Remove("vehicle.yaml")

	_, err = yamlFile.Write(yamlData)
	if err!=nil{
		panic(err)
	}

	// Creating an instance of Vehicle from vehicle.yaml
	var v2 Vehicle
	yamlFile2, err := os.ReadFile("vehicle.yaml")
	if err!=nil{
		panic(err)
	}

	err = yaml.Unmarshal(yamlFile2, &v2)
	if err!=nil{
		panic(err)
	}
	fmt.Println("Instance of Vehicle from vehicle.yaml:")
	fmt.Println(v2)
}

// Output
// Vehicle Instance: {Aston Martin Vantage green 4 {true}}
// Vehicle in YAML format:
// name: Aston Martin Vantage
// color: green
// numwheels: 4
// uses:
//   f1safetycar: true
//
// Instance of Vehicle from vehicle.yaml:
// {Aston Martin Vantage green 4 {true}}

XML

The XML format is commonly used to store test results and configuration. The encoding/xml Go package provides xml.Marshal() and xml.Unmarshal() functions.

If we want the data in a prettified format (with indents on each level) then we can use the xml.MarshalIndent() function. MarshalIndent() is also present in json and gopkg.in/yaml packages.

package main

import (
	"fmt"
	"encoding/xml"
	"os"
)

type Student struct{
	Name string
	IdNum int
	Subjects []string
}

func main() {
	// Storing an instance of Student in XML format
	student1 := Student{
	Name: "John Doe", 
	IdNum: 98, 
	Subjects:[]string{"English", "Maths", "Science"}
	}

	fmt.Println("Example of a Student instance:", student1)

	xmlFile, err := os.OpenFile("student.xml", os.O_CREATE|os.O_RDWR, 0755)
	if err!=nil {
		panic(err)
	}

	defer xmlFile.Close()
	defer os.Remove("student.xml")

	xmlData, err := xml.MarshalIndent(student1, " ", "	")
	if err!=nil {
		panic(err)
	}

	fmt.Println("Student data in XML format:")
	fmt.Println(string(xmlData))

	_, err = xmlFile.Write(xmlData)
	if err!=nil {
		panic(err)
	}

	// Reading an instance of Student from XML File
	var student2 Student
	xmlFile2, err := os.ReadFile("student.xml")
	if err!=nil {
		panic(err)
	}

	err = xml.Unmarshal(xmlFile2, &student2)
	fmt.Println("Student from student.xml:")
	fmt.Println(student2)
}

// Output
// Example of a Student instance: {John Doe 98 [English Maths Science]}
// Student data in XML format:
//  
//         John Doe
//         98
//         English
//         Maths
//         Science
//  
// Student from student.xml:
// {John Doe 98 [English Maths Science]}

Resources

Go by Example
JSON and Go
encoding/json
go-yaml/yaml
gopkg.in/yaml.v2
encoding/xml

Go Programming Language

Wed, 21 Jun 2023 00:00:00 +0000

Go is a compiled language developed by Robert Griesemer, Rob Pike, and Ken Thompson at Google. It is primarily used in cloud-native and web development projects.

Some of the popular projects created with Go

Docker: Container Engine
Kubernetes: Container Orchestrator
Hugo: Static Site Generator (Also used to generate this blog)
Helm: Package manager for Kubernetes

Packages

A Package abstraction is created in Go to group functions that are related to each other or associated with a specific task. At the start of each source file (*.go) a package name is assigned to it using the package keyword, for example, package main.

To import a package we use the import keyword with the name of the package enclosed in "" like import "fmt". The constants, functions, and variables imported from a package are referred to with their first letter capitalized like math.Pi and math.Pow().

package main

import "fmt"

func main () {
	return 0
}

Packages could be bundled together as modules. The go.mod file declares the path to a Go module and all packages within it. A Go module is initialized using the go mod init command followed by the name of the module

go mod init exampleModule

This will generate a go.mod file in the directory specifying the name of the module (exampleModule) and its dependencies.

Standard Input and Output

The fmt package provides functions for standard input and output, these help return output from the program and take inputs from the user respectively. The fmt.Println() function outputs its arguments to the terminal and fmt.Scanln() takes input from the terminal and assigns them to variables. Variations of Println and Scanln provided by fmt:

fmt.Print(): Standard output without any newline at the end.
fmt.Scan(): Values are read from standard input and the newline is interpreted as space.
fmt.Printf(): Standard output in the specified format.
fmt.Scanf(): Reads the value from the terminal in the specified format.

package main

import "fmt"

func main () {
        var name string
        fmt.Print("Your name:")
        fmt.Scan(&name)

        fmt.Println("Hello", name)
}

// Output
// Your name: Joe
// Hello Joe

Building and Executing

To compile and build a Go package as a binary we use the go build command.

go build hello.go

This will create a binary named hello (or hello.exe in Windows) in the current directory that could be executed directly by the host OS.

We can execute a Go package directly from the source file using the go run command.

go run hello.go

Constants

const keyword is used to define constants, values that don’t have to be changed throughout the program. Go supports numeric, character, string, and boolean constants.

package main

import "fmt"

func main () {
        const pi = 3.14
        fmt.Println("Approximate value of Pi is:", pi)
}

// Output
// Approximate value of Pi is: 3.14

Variables and Datatypes

To initialize a variable in Go we have to use the var keyword followed by the name of the variable and its datatype like var intExample int.

Go has the following datatypes

bool for boolean values. Either true or false.
string for storing single or multiple characters.
rune for storing the Unicode code point of a character.
int for integers. Go also supports int8, int16, int32, and int64 where the digits after int signifies the number of bits required to represent the value.
uint for unsigned integers (integers without + or -). uint8/byte, uint16, uint32, uint64 are also available in Go.
Variables of the uintptr type are used to store integer representations of memory addresses. They are useful for performing pointer arithmetic provided by unsafe.Pointer.
float32 and float64 for values that require decimal precision.
complex64 and complex128 are used to represent 64 and 128-bit complex numbers like $5\ +\ i6$ (where $i$ represents $\sqrt{(-1)}$)

package main

import "fmt"

func main () {
        var intExample int
        intExample = 3
        fmt.Println("Integer Example:", intExample)

        var floatExample float64
        floatExample = 2.3
        fmt.Println("Float Example:", floatExample)

        var stringExample string
        stringExample = "Hello, World"
        fmt.Println("String Example:", stringExample)

        var boolExample bool
        boolExample = true
        fmt.Println("Boolean Example:", boolExample)

        var complexExample complex64
        complexExample = complex(5, 6)
        fmt.Println("Complex Number Example:", complexExample)
}

// Output
// Integer Example: 3
// Float Example: 2.3
// String Example: Hello, World
// Boolean Example: true
// Complex Number Example: (5+6i)

To declare and assign values to a variable without explicitly specifying its datatype we use := operand, the variable’s datatype will be inferred during compile time by the value on the right side of the operand.

package main

import "fmt"

func main () {
        intExample := 3
        fmt.Println("Integer Example:", intExample)

        floatExample := 2.3
        fmt.Println("Float Example:", floatExample)

        stringExample := "Hello, World"
        fmt.Println("String Example:", stringExample)

        boolExample := true
        fmt.Println("Boolean Example:", boolExample)

        complexExample := complex(5, 6)
        fmt.Println("Complex Number Example:", complexExample)
}

// Output
// Integer Example: 3
// Float Example: 2.3
// String Example: Hello, World
// Boolean Example: true
// Complex Number Example: (5+6i)

If a variable is initialized without any value then a zero value will be assigned to it by default. Zero values for different datatypes are 0 (for int), 0.0 (for float64), "" (for string), and false (for bool).

package main

import "fmt"

func main () {
    var example1 int
    fmt.Println(example1)
    
    var example2 float64
    fmt.Println(example2)
    
    var example3 string
    fmt.Println(example3)
    
    var example4 bool
    fmt.Println(example4)
}

// Output
// 0
// 0
// 
// false

Type Conversion

Datatypes could also be used as functions for type conversion of variables for example float64(intExample).

package main

import "fmt"

func main () {
        intExample := 4
        fmt.Printf("Float conversion of intExample: %0.2f", float64(intExample))
}

// Output
// Float conversion of intExample: 4.00

Functions

Functions allow us to aggregate frequently used instructions as a single statement. To define a function in Go we use the func keyword followed by the name of the function, its arguments (inputs), and the datatype of the return values like func exampleFunc (inputValue int) (outputValue int) { }

package main

import "fmt"

func square (x int) (int) {
        return x*x
}

func sumAndDifference (x int, y int) (int, int){
        return x+y, x-y
}

func main () {
        value1 := 5
        fmt.Println("Square of", value1, "is:", square(value1))

        value2 := 8
        sum, difference := sumAndDifference(value1, value2)
        fmt.Println("Sum of", value1, "and", value2, "is:", sum)
        fmt.Println("Difference of", value2, "from", value1, "is:", difference)
}

// Output
// Square of 5 is: 25
// Sum of 5 and 8 is: 13
// Difference of 8 from 5 is: -3

Anonymous Functions

Functions are first-class citizens in Go i.e. they could be defined inside variables, passed as arguments, and returned as values from other functions.

Functions with no name (called Anonymous functions) could be created to perform a set of instructions once in a program.

package main

import "fmt"

func main () {
	// Anonymous Function
	func (x int) {
			fmt.Println("Hello, this is not a random number:", x)
	}(1)

	// Function as Variable
	funcExample := func (x int){
			fmt.Println("Example Function")
			fmt.Println("Input:", x)
	}

	funcExample(3)
}

// Output
// Hello, this is not a random number: 1
// Example Function
// Input: 3

Conditions

Go supports if, else if, and else for defining conditional statements.&& (AND) and || (OR) operators could be used to create complex conditional expressions.

package main

import "fmt"

func evaluateGrades (marks int) string {
    if marks < 101{
    	if marks < 40{
    		return "D"
    	} else if marks >= 40{
    		return "C"
    	} else if marks >= 50{
    		return "B"
    	} else if (marks >= 60){
    		return "A"
    	} 
    }
    return "INVALID"
}

func main () {
	marks := 4
	fmt.Println("Grade for marks:", marks, "is:", evaluateGrades(marks))
	
	marks = 40
	fmt.Println("Grade for marks:", marks, "is:", evaluateGrades(marks))

	marks = 51
	fmt.Println("Grade for marks:", marks, "is:", evaluateGrades(marks))

	marks = 101
	fmt.Println("Grade for marks:", marks, "is:", evaluateGrades(marks))
}

// Output
// Grade for marks: 4 is: D
// Grade for marks: 40 is: C
// Grade for marks: 51 is: C
// Grade for marks: 101 is: INVALID

Switch Cases

Sometimes a switch could be relatively clean compared to multiple if and else if statements.

Unlike if-else the first case which satisfies the condition will be executed and the following cases will be ignored. If none of the case conditions are satisfied then the default statement is executed.

package main

import "fmt"

func evaluate (value1, value2, operation int) (int) {
    switch{
        case operation==1:
            return value1+value2
        case operation==2:
            return value1-value2
        case operation==3:
            return value1*value2
        case operation==4:
            return value1/value2
        default:
            return (-1)
    }
}

func main () {
    var value1, value2, operation int
    
	fmt.Println("Calculator Program:")
	fmt.Print("Enter value1:")
	fmt.Scanln(&value1)
	fmt.Print("Enter value2:")
	fmt.Scanln(&value2)
	
	fmt.Println("\nSelect Operation to Perform")
	fmt.Println("1) ADD")
	fmt.Println("2) SUBTRACT")
	fmt.Println("3) MULTIPLY")
	fmt.Println("4) DIVIDE")
	fmt.Print("Enter the operation number:")
	fmt.Scanln(&operation)
	
	fmt.Println("Result of Operation is:", evaluate(value1, value2, operation))
}

// Output
// Calculator Program:
// Enter value1:56
// Enter value2:54
// Select Operation to Perform
// 1) ADD
// 2) SUBTRACT
// 3) MULTIPLY
// 4) DIVIDE
// Enter the operation number:3
// Result of Operation is: 3024

Additional Datatypes

Arrays

We create arrays to store a sequence of values with the same datatype. Go arrays have explicitly defined sizes associated with their datatype.

Individual elements in an array could be accessed by their index (starting from 0). For example, to access the 3rd element in the array we can simply call array[2].

An array is defined as array := [5]int{2, 4, 8, 16, 32}. len() function returns the length of the array.

package main

import "fmt"

func main() {
    var arrayExample [5]int
    fmt.Println("Zero Value Array:", arrayExample)
    
    arrayExample[1]=2
    fmt.Println("Changed arrayExample:", arrayExample)
    
    arrayExample2 := [5]int{2, 3, 1, 3, 21}
    fmt.Println("Another arrayExample:", arrayExample2)
}

// Output
// Zero Value Array: [0 0 0 0 0]
// Changed arrayExample: [0 2 0 0 0]
// Another arrayExample: [2 3 1 3 21]

Slices

A segment of an array could be extracted by creating its slice. To extract a segment starting from index 2 till index 5 in an array called arrayExample we can simply write arrayExample[2:5]

package main

import "fmt"

func main() {
    arrayExample2 := [7]int{2, 3, 1, 3, 21, 234, 23}
    
    lowIndex := 2
    highIndex := 5
    fmt.Println("Slice of arrayExample starting from index",
                lowIndex, "to", highIndex, "is:",
                arrayExample2[lowIndex:highIndex])

    fmt.Println("Slice of arrayExample starting from index",
                lowIndex, "till (including)", highIndex, "is:",
                arrayExample2[lowIndex:highIndex+1])
    
    fmt.Println("Slice Length:", len(arrayExample2[lowIndex:highIndex+1]))
    fmt.Println("Capacity of the original array:",
                cap(arrayExample2[lowIndex:highIndex+1]))
}

// Output
// Slice of arrayExample starting from index 2 to 5 is: [1 3 21]
// Slice of arrayExample starting from index 2 till (including) 5 is: [1 3 21 234]
// Slice Length: 4
// Capacity of the original array: 5

Any changes performed on the slice will also affect the original array.

The cap() function is used to return the capacity of the original array.

The length of the slice is not part of its datatype, so slices are also used as dynamically-sized arrays. A slice is created just like an array but without any size in its declaration like var sliceExample []int

package main

import "fmt"

func main() {
    var capitals []string
    capitals = append(capitals, "delhi")
    capitals = append(capitals, "london")
    fmt.Println("Slice of Capitals:", capitals)
    fmt.Println("Length of Capitals Slice:", len(capitals))
    fmt.Println("Capacity of Capitals Slice:", cap(capitals))
}

// Output
// Slice of Capitals: [delhi london]
// Length of Capitals Slice: 2
// Capacity of Capitals Slice: 2

Maps

To store key-value pairs in Go we have Maps. We can define a map that stores string keys mapped to bool values with the help of make() function like mapExample := make(map[string]bool).

package main

import "fmt"

func main() {
    mapExample := make(map[string]bool)
    mapExample["yes"] = true
    mapExample["no"] = false
    fmt.Println("Example of Map:", mapExample)
}

// Output
// Example of Map: map[no:false yes:true]

Structs

Go is a procedural language but to create data structures with multiple fields we have struct. By creating a struct we are adding a new datatype to our program, that’s why the type keyword is used in its declaration.

While creating an instance of the struct we can pass the value to its fields like maps where the key is the name of the field.

package main

import "fmt"

type dog struct {
    name string
    age int
}

func main() {
    dog1 := dog{name: "DoggyMcDogFace", age: 1}
    fmt.Println("Dog1:", dog1)

    dog2 := dog{name: "AnotherDog", age: 3}
    fmt.Println("Dog2:", dog2)
}

// Output
// Dog1: {DoggyMcDogFace 1}
// Dog2: {AnotherDog 3}

Methods

Methods refer to the functions created to be executed on a specific datatype (like a struct). Their declaration is similar to functions with the addition of struct argument after func keyword like func (d dog) showFields() () { }

package main

import "fmt"

type dog struct {
    name string
    age int
}

func (d dog) showFields() (){
    fmt.Println("Name of Dog:", d.name)
    fmt.Println("Age of Dog:", d.age)
}

func main() {
    dog1 := dog{name: "DoggyMcDogFace", age: 1}
    dog1.showFields()

    dog2 := dog{name: "AnotherDog", age: 3}
    dog2.showFields()
}

// Output
// Name of Dog: DoggyMcDogFace
// Age of Dog: 1
// Name of Dog: AnotherDog
// Age of Dog: 3

Interfaces

Interfaces are used to group common methods.

Interfaces enable polymorphism in Go, which means a method’s behavior is determined by the datatype it is applied upon.

package main

import "fmt"

type ubuntu struct {
    releaseName string
    releaseVersion float64
}

func (u ubuntu) showUpdateCommand() {
    fmt.Println("Update command for", u.releaseName, "is")
    fmt.Println("\tapt-get update && apt-get upgrade")
}

type fedora struct {
    releaseName string
    releaseVersion float64
}

func (f fedora) showUpdateCommand() {
    fmt.Println("Update command for", f.releaseName, "is")
    fmt.Println("\tdnf update")
}

type distro interface {
    showUpdateCommand()    
}

func main() {
    var exampleDistro, exampleDistro2 distro
    exampleDistro = ubuntu{releaseName: "Lunar Lobster", releaseVersion: 23.04}
    fmt.Println("Example of a distro:", exampleDistro)
    
    exampleDistro.showUpdateCommand()
    
    exampleDistro2 = fedora{releaseName: "Fedora 39", releaseVersion: 39.00}
    fmt.Println("Example of another distro:", exampleDistro2)
    
    exampleDistro2.showUpdateCommand()
}

// Output
// Example of a distro: {Lunar Lobster 23.04}
// Update command for Lunar Lobster is
// 	 apt-get update && apt-get upgrade
// Example of another distro: {Fedora 39 39}
// Update command for Fedora 39 is
//	  dnf update

For Loops

Loops allow us to execute a statement multiple times until some condition is valid.

A for loop requires three statements:

initializing statement: This statement will be executed once before the loop has started.
conditional expression: This expression will be evaluated after each execution of the loop. The loop will stop if this expression evaluates to false.
incrementing statement: This statement is executed after each iteration of the loop

package main

import "fmt"

func main() {
    // Initializing Statement: i:=0 (i is initialized with value 0)
    // Conditional Expression: i<10 (until i is less than 10)
    // Incrementing Statement: i++  (increment i by 1)
    for i:=0; i<10; i++ {
        fmt.Println("Value of i:", i)
    }
}

// Output
// Value of i: 0
// Value of i: 1
// Value of i: 2
// Value of i: 3
// Value of i: 4
// Value of i: 5
// Value of i: 6
// Value of i: 7
// Value of i: 8
// Value of i: 9

For Loop over an Array

len(array) will return the length of an array, by using its length we can calculate the last index of an array i.e. len(array)-1. This will help us write a loop that accesses each element of an array using its index.

package main

import "fmt"

func main() {
    arrayExample := [6]int{123, 21, 3, 54, 65, 45}
    for i:=0; i<len(arrayExample); i++ {
        fmt.Println("Element at index ", i, "in arrayExample is", arrayExample[i])
    }
}

// Output
// Element at index  0 in arrayExample is 123
// Element at index  1 in arrayExample is 21
// Element at index  2 in arrayExample is 3
// Element at index  3 in arrayExample is 54
// Element at index  4 in arrayExample is 65
// Element at index  5 in arrayExample is 45

Range

To iterate over data structures such as slices, maps, and strings we can take the help of range. Each iteration of a loop implemented with range will return two values depending on the data structure passed to it:

for string, it will return the byte position of the character and character
for array/slices, it will return the index and the element
for maps, it will return the key and value

package main

import "fmt"

func main() {
    var sliceExample []float64
    sliceExample = append(sliceExample, 4.3)
    sliceExample = append(sliceExample, 5.2)
    sliceExample = append(sliceExample, 64.3)
    sliceExample = append(sliceExample, 34.8)
    fmt.Println("Example of a Slice:", sliceExample)
    
    for index, value := range sliceExample {
        fmt.Println("Value at index", index, "in sliceExample is", value)
    }
    
    stringExample := "Hello, World"
    fmt.Println("Example of a String:", stringExample)
    for pos, char := range stringExample {
        fmt.Printf("%#U character is at position %d\n", char, pos)
    }
    
    mapExample := make(map[int]string)
    mapExample[1] = "one"
    mapExample[2] = "two"
    mapExample[4] = "four"
    fmt.Println("Example of a Map:", mapExample)
    for key, value := range mapExample {
        fmt.Println("Value for key", key, "in mapExample is", value)
    }
}

// Output
// Example of a Slice: [4.3 5.2 64.3 34.8]
// Value at index 0 in sliceExample is 4.3
// Value at index 1 in sliceExample is 5.2
// Value at index 2 in sliceExample is 64.3
// Value at index 3 in sliceExample is 34.8
// Example of a String: Hello, World
// U+0048 'H' character is at position 0
// U+0065 'e' character is at position 1
// U+006C 'l' character is at position 2
// U+006C 'l' character is at position 3
// U+006F 'o' character is at position 4
// U+002C ',' character is at position 5
// U+0020 ' ' character is at position 6
// U+0057 'W' character is at position 7
// U+006F 'o' character is at position 8
// U+0072 'r' character is at position 9
// U+006C 'l' character is at position 10
// U+0064 'd' character is at position 11
// Example of a Map: map[1:one 2:two 4:four]
// Value for key 1 in mapExample is one
// Value for key 2 in mapExample is two
// Value for key 4 in mapExample is four

Substitute for `while` Loop

Go doesn’t have while loops but we can use for loops for the same purpose by executing it with just the conditional expression.

package main

import "fmt"

func main() {
    fmt.Println("Enter an odd number to end the loop")
    
    flag := false
    for flag==false {
            var input int
            fmt.Printf("Enter a value:")
            fmt.Scanln(&input)
            
            if input%2!=0{
                flag=true
            }
    }
    
    fmt.Println("Loop ended")
}

// Output
// Enter an odd number to end the loop
// Enter a value:2
// Enter a value:42
// Enter a value:52
// Enter a value:68
// Enter a value:69
// Loop ended

Pointers

Pointers for a datatype will store the address of a value rather than the value itself. So an integer pointer (*int) will store the address of an integer value.

To fetch the address of a value we use & operand. For example, to fetch the address of the value stored in the intExample variable we call &intExample. Similarly to fetch the value stored at an address we use * operand like *(&intExample).

package main

import "fmt"

func main() {
    intExample := 2
    fmt.Println("Value of intExample:", intExample)
    fmt.Println("Memory address of intExample:", &intExample)
    
    var pointerExample *int
    pointerExample = &intExample
    fmt.Println("Value of pointerExample:", pointerExample)
    fmt.Println("Value stored at pointerExample address:", *pointerExample)
}

// Output
// Value of intExample: 2
// Memory address of intExample: 0xc000022050
// Value of pointerExample: 0xc000022050
// Value stored at pointerExample address: 2

When methods are defined on the pointer of the struct rather than the struct themselves then they can manipulate the value of fields in the original instance rather than its copy.

package main

import "fmt"

type car struct {
    color string
}

func (c car) changeColor(color string) {
    c.color = color
}

func (c *car) changeColorPointer(color string) {
    c.color = color
}

func main() {
    newCar := car{color: "red"}
    fmt.Println("newCar: ", newCar)
    
    // This will not work as the change is not performed 
    // on the original memory address but on its copy
    newCar.changeColor("blue")
    fmt.Println("newCar after changing color: ", newCar)
    
    var newCarPtr *car
    newCarPtr = &newCar
    newCarPtr.changeColorPointer("blue")
    fmt.Println("newCar after changing color using pointer: ", newCar)
}

// Output
// newCar:  {red}
// newCar after changing color:  {red}
// newCar after changing color using pointer:  {blue}

Errors

In Go, errors are like other return types. So a function can return two values one being the output of the function and the other value could be an error interface. We can declare this in the function’s signature like func sampleFunc(value int) (int, error) { }.

A custom error is created using errors.New() function is available in the errors package.

package main

import (
    "fmt"
    "errors"
)

func divide(value1, value2 int) (int, error) {
    if value2==0 {
        return -1, errors.New("Divide by Zero Error. Change value2")
    } 
    return value1/value2, nil
}

func main() {
    var value1, value2 int
    fmt.Printf("Enter value1:")
    fmt.Scanln(&value1)
    fmt.Printf("Enter value2:")
    fmt.Scanln(&value2)
    
    quotient, err := divide(value1, value2)
    fmt.Println("Quotient:", quotient)
    if err!= nil {
        fmt.Println("Error:", err)
    }
}

// Output
// Enter value1:1
// Enter value2:0
// ERROR!
// Quotient: -1
// Error: Divide by Zero Error. Change value2

To catch an unexpected error and exit the program we call the panic() function with a string or the error as its argument. If we don’t want the program to abort on panic() we can follow it up with a recover() function.

Resources

Go by Example
Learn Go in 12 Minutes

Go on avni.sh

REST API Requests in Go

What is REST?

REST Requests

HTTP Verbs

POST

GET

PUT

DELETE

Resources

Concurrency in Go

Goroutines

Channels

Buffering

Select

Timeouts using time.After()

Non-Blocking Channel Operations with default

Closing Channels

WaitGroups

Resources

File Handling in Go

Paths

defer Keyword

Managing Directories

Reading from a File

Writing to a File

Handling Common Filetypes

JSON

Encoding JSON

Decoding JSON

YAML

XML

Resources

Go Programming Language

Packages

Standard Input and Output

Building and Executing

Constants

Variables and Datatypes

Type Conversion

Functions

Anonymous Functions

Conditions

Switch Cases

Additional Datatypes

Arrays

Slices

Maps

Structs

Methods

Interfaces

For Loops

For Loop over an Array

Range

Substitute for while Loop

Pointers

Errors

Resources

`POST`

`GET`

`PUT`

`DELETE`

Timeouts using `time.After()`

Non-Blocking Channel Operations with `default`

`defer` Keyword

Substitute for `while` Loop