Golang is a modern programming language known for its simplicity, efficiency, and performance...

Install, run, and use Golang, Google’s simple and powerful language. Learn the benefits of using Go for your next project and find useful resources and tips.

Get Started With Golang

Get Started With Golang Language

Golang (aka Go) combines C-level efficiency and speed with a more modern and user-friendly syntax, similar to Python. It has a smart built-in garbage collection to optimize memory usage and reduce manual memory management.

Go is a strongly-typed, strongly standard compliant language that provides smart pointers and strictly adheres to a simple coding standard. For example, your code won’t even compile if you have any unused variable, which is generally not the case in other languages. Its official documentation provides a comprehensive guide for beginners to start learning the language.

Golang aside, there are many exotic and user-friendly programming languages like Python, C#, and Java, among others. Why should you bother learning it when you can do the same thing with these?

The answer is simple. Although all the other languages are Turing Complete, each has its unique features, strengths, and weaknesses and is better suited to specific use cases and applications.

Python, for example, is well-known for its ease of use and versatility, but it may not be the best choice for developing high-performance applications that require low-level control over hardware resources. Similarly, while Java is a popular language for developing enterprise software, it may not be the best choice for creating fast and lightweight web applications.

Learning a new programming language like Golang can increase your knowledge of and skill in software development by giving you new perspectives and fresh insights. As a result, you can become a more flexible and in-demand developer.

We’re getting started with Golang by setting it up. Here, we are using Arch Linux, so it is pretty easy (pacman -S go) to install it globally. If you are on macOS or other POSIX operating systems, you can search for it using “Install latest golang on XXX” where XXX is your operating system.

Once this is done, you can confirm it using the go version command:

$ go version
go version go1.20.4 linux/amd64

Why use Golang?

In Go, the GOPATH environment variable is used to specify the location of the Go workspace. The Go workspace is a directory hierarchy where Go source code, packages, and binaries are stored. By default it will be in $HOME/go.

Here’s an example of 3 levels of this hierarchy:

$ /usr/bin/tree -L 3 $HOME/go
/home/tbhaxor/go
├── bin
│   ├── dlv
│   ├── gomodifytags
│   ├── gopls
│   ├── gotests
│   ├── impl
│   └── staticcheck
└── pkg
    ├── mod
    │   ├── cache
    │   ├── github.com
    │   ├── golang.org
    │   ├── gopkg.in
    │   ├── go.starlark.net@v0.0.0-20220816155156-cfacd8902214
    │   ├── honnef.co
    │   └── mvdan.cc
    └── sumdb
        └── sum.golang.org

The reason Go uses GOPATH to save everything is to follow the concept of a workspace, which is a central location for managing Go projects and dependencies.

But this is not a hard and fast rule. Starting from Go 1.11, Go introduced module support which allows you to manage dependencies outside of GOPATH using a go.mod file. With modules, you can specify dependencies and versions on a per-project basis which provides a more modern and flexible approach to dependency management. However, GOPATH is still used for projects that haven't adopted modules or for non-module-based workflows.

In Golang, everything starts with packages and modules so we will also use this new approach to work with it.

Let’s start by creating a module directory and initializing the Go module in it using go mod "init <module name>"

Now, you can verify the contents of the go.mod file in the current directory.

The naming module can be used with or without an internet domain (as shown above). To successfully create the module, a few rules need to be followed.

Go module names should be a valid internet domain or a path within a valid domain.
Example: "go mod init example.com/myproject"

You can use any valid internet domain for module names, even if it doesn't exist on the internet. Example: "go mod init example.com/myproject"

If you don't have an internet domain, you can use a non-existent domain like local or localhost for local projects. Example: go mod init local/myproject or go mod init myproject will also work.

The module name should be unique within the Go ecosystem to avoid conflicts.
Example: "go mod init github.com/yourusername/myproject"

Workspaces

In Go, a package is a way to organize and reuse code. It is essentially a collection of Go source files that have been grouped together to provide related functionality. For example, in the string package, you can have multiple files, each with a different function related to string operations.

These packages can contain functions, variables, constants, types, and other packages. You can define the struct types in types.go and constants in the constants.go file. This can help you remember which file contains the declaration you’re looking for. It can also aid co-developers in navigating code.

The main package in Go is a special package that serves as the starting point for running a Go program. It is the package that contains the main function which serves as the execution starting point. The main package differs from the others in that it generates an executable binary when built. Other packages, known as library packages, are not directly executable on their own but provide reusable code that can be imported and used by other packages or the main package.

Now, create a file in the current directory with any name you want. We’re using main.go to specify explicitly that this file will contain the application's entry function.

Assign the first line to the package main.

package main

import (
	"fmt"
	"os"
)

// main is like any other programming language,
// is the application's entry point.
// Exactly 1 definition of this function is required in main package
func main() {
	// check user has provided any
	// https://pkg.go.dev/os@go1.20.5#Args
	// https://pkg.go.dev/builtin#len
	if len(os.Args) > 1 {
		// take the second element of the array and print hello to user
		// https://pkg.go.dev/fmt@go1.20.5#Printf
		fmt.Printf("Hello, %s\n", os.Args[1])
	} else {
		// if no argument is provided, print message with new line
		// https://pkg.go.dev/fmt@go1.20.5#Println
		fmt.Println("Hello Guest")
	}
}

In the above code, we’re using the built-in function len() from Golang runtime to check if the length of CLI arguments is greater than 1. Even if the user doesn’t provide any input, it will still have 1 element, which is the name of the file itself.

There are two ways to run the code: build first and then run it or simply use go run . in the module directory. This is used to compile and run a Go program in one step. When learning or testing the code, you may find it more convenient to use this instead of building first and then running the binary file.

Note: You can use the following command to print the actual path of the compiled code from your temp directory.

If you want to build the executable first and then run it, you can achieve this using go build. command. This will create the executable file in the current directory which you can verify by file command. You can now run the executable file as any other executable file.

In Linux, if the binary file is not in the PATH directory, you will need to execute this binary file using ./helloworld instruction.

Packages and main package

In Golang, the capitalization of a function name affects its visibility. Functions with the first character in uppercase are exported during compilation, which means they can be called from other packages. Functions with names that begin with a lowercase letter are not exported, so they can only be invoked from within the package in which they are declared.

Let’s say we have otherpackage with the following Golang example code in it:

package otherpackage

import "fmt"

// greetname will print hello to name
func greetname(name string) {
	fmt.Printf("Hello, %s\n", name)
}

// greetguest will print a simple string
func greetguest() {
	fmt.Println("Hello, Guest")
}

// Greet will print greetguest or greetname based on length of names
func Greet(names []string) {
	if len(names) == 0 {
		greetguest()
	} else {
		for _, name := range names {
			greetname(name)
		}
	}
}

You can now use the Greet method outside of this package. Here’s a demonstration of how to use this function in the main package of the same module.

package main

import (
	"os"

	"funcname/otherpackage"
)

func main() {
	// call the exported function
	otherpackage.Greet(os.Args[1:])
}

Function name convention

Variables are used in programming languages to temporarily store data that can change during runtime. They are given a name and a value, and can be used to refer to that value throughout the program. Variables can help with a variety of tasks, including:

Accepting inputs from the users at runtime.

Unlike other languages, in Go you can define variables using various syntaxes depending on the context. Here are some different ways to define a variable:

Standard declaration is used to declare a variable with a specific data type using the var keyword.

Type inference is used to declare a variable and let the Go compiler infer its data type based on the assigned value using the := syntax.

Multiple variable declaration is used to declare multiple variables with their respective data types using the var keyword within parentheses.

Short declaration for multiple variables is used to declare and assign multiple variables in a concise way using the := syntax with comma-separated values.

Here is an example of each of the following ways discussed above:

package main

import "fmt"

func main() {
	// Golang forbids unused variables
	// uncomment following line to give compile-time error
	// var unused_var string

	// Standard declaration: var variableName dataType
	var age int

	age = 20 // reassigning values to the variable

	// Type inference: variableName := value
	name := "John"

	// Multiple variable declaration: var ( variable1 dataType1 variable2 dataType2 )
	var height, weight float64

	// Short declaration for multiple variables: variable1, variable2 := value1, value2
	country, population := "INDIA", 142.03

	// Printing the values of the variables
	fmt.Println("Age:", age)
	fmt.Println("Name:", name)
	fmt.Println("Height:", height)
	fmt.Println("Weight:", weight)
	fmt.Println("Country:", country)
	fmt.Println("Population:", population)

}

If you are a developer who declares variables first and defers its usage, you will face problems when initially learning Go. This is because it is a compile-time error to declare a variable and not use it anywhere in the code. This rule helps to ensure that the code remains clean and avoids unnecessary clutter.

When you parse the code with a go-staticcheck tool, it will warn you if you initialize variables like this. As stated in the warning, this "literal" assigning right after declaration can be merged.

var age int = 20

// or by default integer literals are typed as int
var age = 20

Local variables are stored in the stack memory, which is automatically deallocated when the function execution is finished. Global variables, including those allocated with the new() function, are persistently stored in heap memory.

All these variables seen so far are initialized on the stack and are cleared as soon as this function goes out-of-scope.

Variables and datatypes

Garbage collection is an automatic memory management mechanism used by some programming languages to reclaim memory that the program no longer uses. It is required to ensure efficient memory utilization, prevent memory leaks, and relieve programs of the burdens of manual memory management. It guarantees no memory related error as it is implemented by the developers of the programming language.

Although garbage collection is executed automatically by Golang runtime, you can also run it manually using the runtime standard library. You can try the following code as an example:

package main

import (
	"fmt"
	"runtime"
)

const maxHeapSize = 2 * 1024 * 1024 * 1024 // 1GB

func runGC() {
	fmt.Println("--- Demonstrating GC ---")
	// create 2 gb of junk memory
	var junk = make([]byte, maxHeapSize)
	fmt.Println(junk[:10])

	// run gc manually on the allocated
	fmt.Println("Running GC")
	runtime.GC()
	fmt.Println("\nGC Finished")
}

package main
 
 func main() {
+       runGC()
 }

Note: GC runs a garbage collection and blocks the caller until the garbage collection is complete. It may also block the entire program.

Run the program with the GODEBUG environment variable set to gctrace=1 option. It instructs the Go runtime to emit a single line to standard error after each garbage collection, containing a summary of the amount of memory collected and the length of the pause. The gctrace flag is one of several debugging flags available in Go. You can learn more about these flags by reading the documentation for the runtime package.

At first, each of these lines may look like gibberish. But once you get the hang of the format, it will make sense. This is debug information printed by the runtime after clearing the memory. The output is a population of the following template:

gc # @#s #%: #+#+# ms clock, #+#/#/#+# ms cpu, #->#-># MB, # MB goal, # MB stacks, #MB globals, 
# P

where the fields are as follows (taken from the runtime pkg documentation):

        gc #: the GC number, incremented at each GC.
	@#s: time in seconds since program start.
	#%: percentage of time spent in GC since program start.
	#+...+#: wall-clock/CPU times for the phases of the GC.
	#->#-># MB: heap size at GC start, at GC end, and live heap.
	# MB goal: goal heap size.
	# MB stacks: estimated scannable stack size.
	# MB globals: scannable global size.
	# P: number of processors used.

Garbage collection

Stack and heap are two important memory management concepts in Go, as they are in many other programming languages. As you can see, the variables are defined in the stack so far. But what exactly is a stack?

The stack is a region of memory where local variables and function call information are stored. When a function is called, a stack frame is allocated to store its local variables, return address, and other relevant information. The stack is arranged in a last-in-first-out (LIFO) fashion, which means that the most recently pushed item is the first to be popped off.

The heap is a memory region that is used for dynamic memory allocation and deallocation. It is used to store data that must persist beyond the lifetime of a single function call or when the data size is unknown at compile time. The Go runtime manages the heap, which allows for flexible memory allocation. The heap is used in Go to store complex data types such as structs, slices, maps, large arrays, and pointers.

In Go, when you create an object using the new keyword or built-in functions like make, memory is allocated on the heap. Unlike languages like C, the Go garbage collector automatically manages deallocation to prevent memory leaks.

The stack is used in Go to store primitive data types such as integers, booleans, and pointers to data on the heap. Allocating and dealing with memory on the stack is faster than on the heap because it is managed efficiently and has a fixed size.

Stack and heap

Like every programming language, pointers in Golang are variables that hold the memory address of value. This value can either be in the stack or heap. They just store their address. The pointer itself is allocated on the stack.

Pointers come in handy when you want to access and modify data in memory indirectly. Below, we will be using references to pass values to functions. This is an interesting technique for reducing copying time for large data structures such as structs or arrays.

Let's say we have a large array of integers and we want to modify its elements. Instead of making a copy of the entire array, we can use a pointer to efficiently access and modify the original array in memory.

package main

import (
	"fmt"
)

func pointers() {
	fmt.Println("--- Demonstrating Pointer Variables ---")
	// Create an array of integers
	array := [3]int{1, 2, 3}
	fmt.Println(array)

	// Create a pointer to the array
	pointer := &array

	// Modify the second element of the array using the pointer
	// * is used to dereference the pointer
	(*pointer)[1] = 10

	// Print the modified array
	fmt.Println(array)

	// allocate new int type pointer
	num := new(int)
	*num = 10
	fmt.Println(num, *num)
}

Now, you have to call this function from the main function of the program to see the following output.

Pointers

In Go, variables have different scopes that determine where they can be accessed within the code. The main scopes in Go are local, global, and file/package scope.

Local variables have a limited scope and are accessible only within a specific block of code, typically enclosed within curly braces { ... }. Once the execution of the block is complete, local variables are deallocated from the stack memory.

Global variables, on the other hand, have a scope that spans the entire lifetime of the program. They are accessible from any part of the codebase and are stored in the heap memory. Global variables are typically used when a value needs to be shared across multiple functions or packages.

Package scope refers to variables that are defined in a different package. These variables can be accessed by all the functions within the same file or package and can be accessed outside the package only if they start with upper-case letters. They have a similar lifetime to global variables and are often used for configuration settings or constants that are used throughout the codebase.

When there are multiple variables with the same name in different scopes, the most closely defined variable takes priority. This means that if a local variable is defined within a block, it will overshadow any variable with the same name defined in a higher scope.

import "fmt"

// you cannot use shorthand := initialization on global scope
var globalVariable = 10

func printVariables() {
	fmt.Println("--- Demonstrating Variable Scopes ---")
	localVariable := 5

	// Print global and local variables within main function
	fmt.Println("Global:", globalVariable)
	fmt.Println("Local (main):", localVariable)

	{
		// Declare local variables within compound block
		localVariable := 7
		anotherLocalVariable := 15
		globalVariable := 20

		// Print local and global variables within compound block
		fmt.Println("Local (block):", localVariable)
		fmt.Println("Another local (block):", anotherLocalVariable)
		fmt.Println("Global (block):", globalVariable)
	}

	// Print local and global variables after the compound block
	fmt.Println("Local (main, after block):", localVariable)
	fmt.Println("Global (main, after block):", globalVariable)
}

You need to call the function in the main package as shown below. This will give you the following output:

package main

func main() {
	variableInitialization()
	printVariables()
}

You are seeing the output of variable initialization because we have written the code in the same package but different file, scope.go.

Variable scopes

Arrays are a fixed-length data structure that can hold elements of the same type. They are declared with a type and a size. For example, the following declares an array of 5 integers:

The entries/elements of an array can be accessed by their index, which starts from 0. For example, the following code will print the first element of the numbers array:

Since this array is initialized with all zero values, any value you use for index from 0 →4 will print 0 on the stdout.

package main

import "fmt"

func arrays() {
	fmt.Println("--- Demonstrating Arrays ---")

	// declare array of 5 elements of type int which are initialized to 0
	var numbers [5]int

	// print first element of the
	fmt.Println(numbers[0])

	// underscore variables are ignored from unused variables
	// proof all the elements are zero
	sum := 0
	for _, el := range numbers { // this can also be for i := 0; i < len(numbers); i++
		sum += el
	}
	fmt.Println(sum)

	// length of array, here it will be 5
	fmt.Println(len(numbers))

	// this will give a compile-time error, going beyond allocated area
	// numbers[5] = 10; // uncomment this to get error

	// set value at particular index, only int values are allowed
	numbers[2] = 100

	// print whole array at once, this is allowed
	fmt.Println(numbers)
}

If you are unsure about the number of elements to store and need a data structure that can be resized, an array is not a good choice because it cannot be resized. In such cases, it is best to use a slice that supports dynamic resizing.

Slices are declared with a type and a range of elements. For example, the following declares a slice of 3 integers:

var slices []int = []int{1, 2, 3}
// or you can use the array
var slices = numbers[0:3] // here it is starting from the first element

At this time, both the length and capacity of this slice will be 3. But as soon as you append to the slice, it will multiply the capacity of slice with 2, copy content, and append the item at the end of the slice.

package main

import "fmt"

func slices() {
      fmt.Println("--- Demonstrating Slices ---")
	var numbers [5]int // just for demo

	// initialize slice from the length
	var slice1 []int = numbers[:3]

	// print length and capacity of slice1
	fmt.Println(len(slice1), cap(slice1))

	// convert whole array to slice
	var slice2 []int = numbers[:]

	// print length and capacity of slice2
	fmt.Println(len(slice2), cap(slice2))

	// you can have slice without any array like this,
	// if you remove the right hand side, that will be length 0 capacity 0 slice
	var slice3 []int = []int{1, 2, 3, 4, 5, 6, 7, 8, 9}

	// print length and capacity of slice3
	fmt.Println(len(slice3), cap(slice3))

	// print slice before append
	fmt.Printf("%v\t%p\n", slice3, &slice3)

	// append element to the last of slice
	slice3 = append(slice3, 10)

	// print slice after append
	fmt.Printf("%v\t%p\n", slice3, &slice3)

	// print length and capacity of slice3
	fmt.Println(len(slice3), cap(slice3))

	deleteIndex := 3

	// deleting third index from the slice
	slice3 = append(slice3[:3], slice3[deleteIndex+1:]...)

	// print slice after delete
	fmt.Printf("%v\t%p\n", slice3, &slice3)

	// print length and capacity of slice3
	fmt.Println(len(slice3), cap(slice3))

	// create slice with different length and capacity
	var slice4 = make([]int, 10, 20)

	// print length and capacity of slice2
	fmt.Println(len(slice4), cap(slice4))

	// this will iterate until length is reached

	for idx := range slice4 {
		fmt.Printf("%d ", idx)
	}
	fmt.Println()
}

Hashmaps are a type of data structure that associates keys with values. This gives the option of selecting the type of key. In terms of hashmaps, for example, the type of key of slices and arrays is fixed to integer type with zero. Hashmaps are declared with a type for the keys and a type for the values.

For example, the following declares a hashmap that maps strings to integers:

// both key-value pair are string type
// you can also use make, make(map[string]int)
var myMap map[string]string = map[string]string{}

Elements of a hashmap can be accessed by their key. For example, the following code will check if the key "Alice" exists in the people hashmap and return its value if it does:

// get value from the map
value, exists := myMap["Alice"]
if exists {
	fmt.Println(value)
} else {
	fmt.Println("Key not found") // this will be printed
}

Hashmaps are a very efficient way to store and retrieve data, but they can be slower than arrays or slices for some operations. For example, iteration using loop and sorting.

package main

import (
	"fmt"
)

func hashMaps() {
	fmt.Println("--- Demonstrating Hashmaps ---")

	// both key-value pair are string type
	// you can also use make, make(map[string]int)
	var myMap map[string]int = map[string]int{}

	// get value from the map
	value, exists := myMap["Alice"]
	if exists {
		fmt.Println(value)
	} else {
		fmt.Println("Key not found") // this will be printed
	}

	// set or update value for the key Alice
	myMap["Alice"] = 20

	// print entire map
	fmt.Println(myMap)

	// when you are certain the key exists
	// feel free to ditch if-else
	value = myMap["Alice"]
	fmt.Println(value)

	// gives the number of pairs
	fmt.Println(len(myMap))

	// range based for loop gives key on left and value on right side
	for key, value := range myMap {
		fmt.Printf("Key=%s\tValue=%d\n", key, value)
	}

	// delete the key if it exists
	delete(myMap, "Alice")
	fmt.Println(len(myMap))

}

Arrays, slices, and hashmaps

Functions are blocks of code that are used to encapsulate common logic and make it reusable in order to improve readability and make code look more concise. They usually sit in the execution memory, but are called using a special operator, (), also called call operator.

The syntax for declaring a function in Golang is as follows:

func function_name(parameter_list) (return_type) {
  // function body
}

function_name is the name of the function.

parameter_list is a list of parameters that the function takes.

return_type is the type of the value that the function returns.

// function body is the code that is executed when the function is called.

In Golang, slices and hashmaps are passed by reference. This means that when you pass a slice or hashmap to a function, the function receives a reference to the slice or hashmap rather than a copy. So any changes made to the slice or hashmap by the function will be reflected in the original slice or hashmap.

The init() function is a special function that is called before the main() function. It is used to initialize any variables or other resources that must be available prior to the execution of the main() function.

var i = 10

// called before main()
func init() {
	fmt.Println("Initialization function for main")
	i = 20
}

If the init() function is declared in the importing package, it will be called before the init() function in the imported package. This is because the Go compiler will first initialize all of the imported packages and will then initialize the importing package.

// called before init of main package
func init() {
	fmt.Println("Initialization function for otherpackage")
}

A function may return multiple values simultaneously. This can be beneficial for functions that need to return multiple pieces of data or that need to return both the result and an error value. If you want a function to return more than one value, simply list the return values in the function signature, separating them with commas.

func multiple_returns(a, b int) (int, int) {
	sum := a + b
	product := a * b
	return sum, product
}

In the funcname workspace, I've put an arithmetic package in place. Some of the functions like Add, Sub, and Prod can be defined straightforwardly. However, we have added a safeguard for 0 divisors in the Div function and it now returns an error in that circumstance. The Do function returns a number of values.

package arithmetic

import "errors"

func Div(a, b int) (float32, error) {
	if b == 0 {
		// divide by zero is undefined
		// if user provided this value, then send 0 and error
		return 0, errors.New("divide by zero error")
	}

	// since division can be fractional, convert operands to float32()
	// if b != 0 then we can safely divide and return value
	// error interface is allowed store and return nil values
	// only pointers and error can be assigned to nil
	return float32(a) / float32(b), nil
}

When the code is executed, the output should be as follows:

A function is exported if its name starts with a capital letter. This means that the function can be used by other packages. If a function's name does not start with a capital letter, it is not exported and can only be used by the package in which it is defined.

// this will not be exported
func helloWorld() {
	// body goes here
}

// this will be exported
func HelloWorld() {
	// body goes here
}

We have already used this in the Packages and Main Package section. You can check the funcname workspace in the code repository.

The main function is special because it is the entry point for every Golang program. This means that the main function is the first function that is executed when the program starts. It also differs from other functions in that it does not have to return a value.

The defer keyword is used to delay the execution of a function until the surrounding function completes. It is executed in LIFO order to perform cleanup tasks, handle panics, and more.

There are two ways to declare defer functions in Golang: anonymous defer functions and named defer functions. Anonymous defer functions are declared without a name. They are often used for releasing resources or recovering from panics. On the other hand, named defer functions are declared with a name. They are used for more complex tasks such as logging or sending an email.

The following code snippet shows both examples:

func main() {
	// defer function 1
	// order of execution 3
	defer func() {
		fmt.Println("world")
	}()

	// defer function 2
	// order of execution 2
	defer fmt.Println("hello")

	// open file
	file, _ := os.Open("somefile.txt")

	/**
	Do some changes in the file
	*/

	// close the file as function ends
	// defer function 3
	// order of execution 1
	defer file.Close()
}

Functions

In Golang, a struct is a user-defined data type that is made up of different types. These can include arrays, hashmaps, other structs, and basic data types.

Below, the Person struct has two fields: name and age. The name field is a string and the age field is an unsigned integer.

type Person struct {
	name string
	age  uint
}

Any function can initialize them as shown below. While defining, you can opt to omit the ampersand (&) sign before the struct name. To make things simpler when dealing with pass by reference, we have implemented it this way and return the object's pointer.

person := &Person{name: "Gurkirat Singh", age: 21}

Like function, the struct itself and its properties can be exported by capitalizing their first character.

To print the whole struct, you can use the fmt.Println() or fmt.Printf()  function with the %+v format verb. This will print the struct with its field names and values. For example, the following code prints the whole Person struct:

// print entire struct
fmt.Printf("%+v\n", person)

// print selective fields of struct
fmt.Printf("Name=%s\t\tAge=%d\n", person.name, person.age)

Updating a value in a struct in Golang is as simple as assigning a new value to the field. For example, the following code updates the value of the name field in the Person struct:

// change value
person.name = "Amit"
fmt.Printf("%+v\n", person)

Methods are functions that are associated with a struct. They can be used to access or modify the data in a struct. Like regular functions, they are defined using the func keyword. However, methods also have a receiver, which is the struct that the method is associated with. The receiver is specified after the func keyword and is enclosed in parentheses.

func (p *<struct type>) methodName() {
	// implementation here
}

For example, the following code defines a method for the Person struct called whoami():

// this a method attached to each instance of struct
func (p *Person) whoami() {
	fmt.Printf("Hi! I am %s and %d years old\n", p.name, p.age)
}

And then, you call as you call methods in other OOPs-based languages.

Struct embedding is a technique for creating a new struct that contains the fields of another struct. This can help with code reuse and the creation of more complex data structures.

When you embed a struct, you do not make a duplicate of the embedded struct. You are instead making a reference to the embedded struct. This means that any changes you make to the embedded struct are mirrored in the embedding struct.

For example, the following code defines a struct called Employee that embeds the Person struct:

// define struct with embedding Person struct
type Employee struct {
	Person  // embedding happens here
	email   string
	website string
}

Here is an example of how to instantiate the Employee struct:

// instantiate Employee struct and pass person information
// since person was point, it needs to be dereferenced
employee := &Employee{Person: *person,
	email:   "info@tbhaxor.com",
	website: "https://tbhaxor.com",
}

As you can see, the Employee struct has access to all of the fields of the Person struct. You can now access properties of Person either using direct ".<age|name> or .Person.<age|name>".

Ultimately, the decision of whether or not to use struct embedding in your Golang code is up to you. There are benefits and drawbacks to both.

Code reuse: It allows you to reuse the fields and methods of an existing struct in a new struct. This can help to reduce code duplication and improve code readability.

Modularity: It helps make code more modular by allowing you to break down complex types into smaller, more manageable ones, enabling code to be easier to understand and maintain.

Increased complexity: If done carelessly, it will make code more complex, especially when you embed multiple structs.

Ambiguity: If you are embedding structs with the same field names, there can be ambiguity in the field you are referring to. This can lead to errors in your code.

The programmer needs to weigh the benefits and drawbacks before making a decision.

package main

import (
	"fmt"
)

// define struct with two field
type Person struct {
	name string
	age  uint
}

// this a method attached to each instance of struct
func (p *Person) whoami() {
	fmt.Printf("Hi! I am %s and %d years old\n", p.name, p.age)
}

// define struct with embedding Person struct
type Employee struct {
	Person  // embedding happens here
	email   string
	website string
}

func main() {
	// initialize object of Person struct with values
	person := &Person{name: "Gurkirat Singh", age: 21}

	// print entire struct
	fmt.Printf("%+v\n", person)

	// print selective fields of struct
	fmt.Printf("Name=%s\t\tAge=%d\n", person.name, person.age)

	// change value
	person.name = "Amit"
	fmt.Printf("%+v\n", person)

	// call method of person instance
	person.whoami()

	// instantiate Employee struct and pass person information
	// since person was point, it needs to be dereferenced
	employee := &Employee{Person: *person,
		email:   "info@tbhaxor.com",
		website: "https://tbhaxor.com",
	}
	fmt.Printf("%+v\n", employee)

	// access value of embedded struct directly
	// from employee object
	employee.name = "Amit Singh"
	fmt.Printf("%+v\n", employee)

	// methods also gets embedded
	employee.whoami()
}

Structs

Interfaces, which are collections of method signatures, are used in Golang to achieve polymorphism. Methods represent a type's behavior, whereas properties represent a type's state. Methods are polymorphic rather than properties because methods are more reusable. Any type that implements the interface, regardless of its state, can use a method. This makes it easier to create new types that can interoperate with existing types.

For example, the Shape2D interface defines methods on 2D shapes such as get area and perimeter:

type Shape2D interface {
	Area() float32
	Perimeter() float32
}

The Shape2D interface has two methods, Area() and Perimeter(), that return float32 type. Any type that implements the Shape interface must implement the Area() method.

func print2DShapeDetails(shapes ...Shape2D) {
	for _, shape := range shapes {
		fmt.Printf("Area=%.3f\tPerimeter=%.3f\n", shape.Area(), shape.Perimeter())
	}
}

The print2DShapeDetails() function takes an array of Shape2D interface as a parameter. This means that the function can be called with any type that implements the Shape2D interface.

Similarly, different struct types can be initialized with the same interface name and the same array if - and only if - they implement the same functions in their structs.

// instantiate all the structs in array
shapes := []Shape2D{
	&Square{size: 4},
	&Rectangle{length: 3, width: 4},
	&Circle{radius: 10},
	&Triangle{a: 3, b: 4, c: 5},
}

Note: You can check the code in the polymorphism directory of the code repository for actual implementation of Area() and Perimeter() methods.

You can now call print2DShapeDetails() and provide it with the shapes slice as shown below.

Type assertion is a powerful mechanism that allows developers to access the underlying concrete value of an interface variable. With type assertions, you can determine whether an interface variable holds a specific type and then perform operations based on that knowledge.

value, ok := someInterfaceVariable.(desiredType) 

Here, value represents the underlying concrete value if the assertion is successful. ok is a boolean indicating whether the assertion succeeded. If you are certain about the successful assertion, you may omit the ok variable.

For example, the following code searches for an instance of Circle struct within the shapes slice. If it is found, it prints the index, radius, and calls print2DShapeDetails() function.

for idx, shape := range shapes {
      // check if the underlying type of Shape2D is Circle
	circle, ok := shape.(*Circle)
	if ok {
		fmt.Printf("Found circle shape at %d index\n", idx)
		fmt.Println("Radius of circle", circle.radius)
		print2DShapeDetails(circle)
		break
	}

}

Polymorphism using interfaces

A switch statement combined with a type assertion can be used to execute different blocks of code based on the type of a variable.

The syntax for a switch statement with a type assertion is:

switch variable.(type) {
case type1:
	// Code to execute if the variable is of type1
case type2:
	// Code to execute if the variable is of type2
default:
	// Code to execute if the variable is not of type1 or type2
}

// or you can define the variable for the specific type in switch statement
switch v := variable.(type) {
case type1:
	// type of v is type1
case type2:
	// type of v is type2
default:
	// Code to execute if the variable is not of type1 or type2
}

For example, the following code iterates through each shape and prints information about it, such as the radius, if a circle is found.

func getTypeDetails(shapes ...Shape2D) {
	for _, shape := range shapes {
		// 'shape.(type)' syntax is used within the type switch
		// to get the actual type of 'shape'.
		switch shape := shape.(type) {
		case *Circle:
			fmt.Printf("[Circle]\tr=%.2f\n", shape.radius)
		case *Triangle:
			fmt.Printf("[Triangle]\ta=%.2f\tb=%.2f\tc=%.2f\n", shape.a, shape.b, shape.c)
		case *Rectangle:
			fmt.Printf("[Rectangle]\tl=%.2f\tw=%.2f\n", shape.length, shape.width)
		case *Square:
			fmt.Printf("[Square]\ts=%.2f\n", shape.size)
		}
	}
}

Once you have assembled the whole code, it will give you following output:

Switch statement

Panic is a special function in Golang that is used to raise exceptions and stop the normal execution of the program immediately. Think of it as similar to “throw” or “raise” keywords in other languages. Panic is used to signal that an unrecoverable error has occurred, while recover is used to recover from a panic.

For example, we are parsing two command-line arguments and converting them to ints. If the user provided insufficient arguments or was unable to parse, it will immediately throw a panic with an error code.

func getInput() (int, int) {
	if len(os.Args) < 3 {
		// panic can accept type of any value
		panic("minimum 3 arguments required")
	}

	num1, err := strconv.ParseInt(os.Args[1], 10, 32)
	if err != nil {
		panic(err)
	}
	num2, err := strconv.ParseInt(os.Args[2], 10, 32)
	if err != nil {
		panic(err)
	}

	return int(num1), int(num2)
}

The divide() function wraps the arithmetic.Div() function to ensure that any errors that occur during the division are handled gracefully. Panicking with the error message or an error object as shown below:

func divide(a, b int) float32 {
	if div, err := arithmetic.Div(a, b); err != nil {
		// if any error, panic the error
		panic(err)
	} else {
		return div
	}
}

If you call these functions in the main(), it will generate the following output:

However, as previously stated, this error message does not appear graceful. In addition, if any file or database connection was open, it would have remained open until it timed out or executed extra commands to close the file or connection.

You can postpone a function that runs before the program is halted by panic and recover from it. If an error occurs, you can use os.Exit(1) to close the connection or handles, format and display the error message, and exit your Golang program.

The ideal position of defining defer function with recover() body is at the start of the function definition. This way, you are assured that it will recover errors anytime.

package main

import (
	"fmt"
	"os"
	"strconv"

	"funcname/arithmetic" // using Div function arithmetic package of funcname workspace
)

func divide(a, b int) float32 {
	if div, err := arithmetic.Div(a, b); err != nil {
		// if any error, panic the error
		panic(err)
	} else {
		return div
	}
}

func getInput() (int, int) {
	if len(os.Args) < 3 {
		// panic can accept type of any value
		panic("minimum 3 arguments required")
	}

	num1, err := strconv.ParseInt(os.Args[1], 10, 32)
	if err != nil {
		panic(err)
	}
	num2, err := strconv.ParseInt(os.Args[2], 10, 32)
	if err != nil {
		panic(err)
	}

	return int(num1), int(num2)
}

func main() {
	defer func() {
		switch err := recover().(type) {
		case string:
			fmt.Println("ERROR", err)
			os.Exit(1)
		case error:
			fmt.Println("ERROR", err.Error())
			os.Exit(1)
		}
		// // or you can simply print
		// if err := recover(); err != nil {
		// 	fmt.Println("ERROR:", err)
		// 	os.Exit(1)
		// }
	}()

	a, b := getInput()
	fmt.Println(a, "/", b, "->", divide(a, b))
}

FOR DEVELOPERS

Get Started With Golang Language

Author

Gurkirat Singh

Getting Started With Absolute Value Abs() In Java

Best Practices for Securing Your ReactJS Application

Introduction to Pytest Framework

How to Check for NaN Values in Python?[With Examples]

Getting Started With MongoDB Shell & Basic Commands

Frequently Asked Questions

Press

Blog

Contact

Hire remote developers