Go Interview Questions

Go programming language is an open-source programming language developed at Google. It is similar to C language but with some additional features such as Garbage collection, memory safety, CSP-style concurrency and structural typing. It is referred to as Golang because it’s domain is golang.org. Golang is emerged as an alternative to Java and C++ for the development of distributed systems. It is a great fit when you want to develop a small MicroService very quickly. it’s very easy to learn for developers with existing programming skills.

Go language provides these basic data types:

bool
string
int, int8, int16, int32, int64
uint uint8 uint16 uint32 uint64 uintptr
byte // alias for uint8
rune // alias for int32
float32 float64
complex64 complex128

You can use the NumCPU method of the runtime package to determine the number of processors used in the current process.

• package main import ( “fmt” “runtime” ) // Main function func main() { // Get number of processors using the NumCPU function fmt.Println(runtime.NumCPU()) }

• In Go programming language, runes is a package which provides transformation functions for UTF-8 encoded text. For more about the runes package, visit runes pkg.
• Map function provides you a Transformer, which is responsible to map the runes in input string based on defined mapping. For more visit Map function.

• In Go language, runtime is a library used by programs at execution time. It manages the memory, garbage collector and go-routine scheduler etc. It is not a full runtime environment like CLR in C# and JVM in Java. For more about go runtime visit go runtime.
• The runtime package provides you operations which interact with go runtime such as to control the garbage collector, scheduler and goroutines, etc. For more visit runtime package.

Golang supports two kinds of expressions:

• lvalue − The expressions which are referred to as memory locations are known as “lvalue” expressions. It appears either on the right-hand or left-hand side of an assignment operator.
• rvalue − It refers to a data value that is stored at some address in memory. It cannot have a value assigned to it. So rvalues always appear on the right side of the assignment operator.

You can compare two structs with the “==” operator, as you would do with other types. Make sure they don’t contain any functions, maps, or slices in which the code will not be compiled.

In GO Array works differently than it works in C

• Arrays are values, assigning one array to another copies all the elements.
• If you pass an array to a function, it will receive a copy of the array, not a pointer to it
• The size of an array is part of its type. The types [10] int and [20] int are distinct

Type conversion is used to convert dissimilar types in GO. A type assertion takes an interface value and retrieve from it a value of the specified explicit type.

To format a string without printing you have to use command

return fmt.Sprintf ( “at %v, %s” , e.When , e.What )

A string literals represents a string constant obtained from concatenating a sequence of characters.

• There are two forms,
• Raw string literals: The value of raw string literals are character sequence between back quotes ‘‘. The value of a string literal is the string composed of the uninterrupted character between quotes.
• Interpreted string literals: It is represented between double quotes ““. The text between the double quotes which may not contain newlines, forms the value of the literal.

Every GO program is made up of packages. The program starts running in package main. This program is using the packages with import paths “fmt” and “math/rand”.

The GOPATH environment variable determines the location of the workspace. It is the only environment variable that you have to set when developing Go code.

• GO compiles very quickly
• Go supports concurrency at the language level
• Functions are first class objects in GO
• GO has garbage collection
• Strings and Maps are built into the language

It is a function that runs concurrently with other functions. If you want to stop it, you will have to pass a signal channel to the goroutine, which will push a value into when you want the function to finish.

The command line argument can be accessed using the os.Args variables.

For instance:
Package main
import (
“fmt”
“OS”
)
func main () {
fmt.Println(len(os.Args), os.Args)

To test on Golang, follow these steps:

• Create a file and end it with _test.go.
• This file should contain the TestXxx functions as described.
• Now, put this file in the same package as the one which is being tested.
• This file will now be included in the “go test” command.

A goroutine is a function which usually runs concurrently with other functions. If you want to stop goroutine, you pass a signal channel to the goroutine, that signal channel pushes a value into when you want the goroutine to stop.

The goroutine polls that channel regularly as soon as it detects a signal, it quits.

Quit : = make (chan bool)
go func ( ) {
for {
select {
case <- quit:
return
default
// do other stuff
}
}
}()
// Do stuff
// Quit goroutine
Quit <- true

When a pointer is assigned “nil”, it called a nil pointer. It is a constant with a “zero” value defined in standard libraries.

Golang uses the following types:

• Method
• Boolean
• Numeric
• String
• Array
• Slice
• Struct
• Pointer
• Function
• Interface
• Map
• Channel

Go Array allows programmers to define factors that can hold information of a similar kind yet not give any strategy for building size or for getting a sub-exhibit. Slice takes care of this limitation. It provides utility functions needed on Array and is a part of Go programming.

Function closures is a function value that references variables from outside its body. The function may access and assign values to the referenced variables.

example: adder() returns a closure, which is each bound to its own referenced sum variable.

In Go language, defer statements delay the execution of the function or method or an anonymous method until the nearby functions returns. In other words, defer function or method call arguments evaluate instantly, but they don’t execute until the nearby functions returns

Multithreading is a model of program execution that allows for multiple threads to be created within a process, executing independently but concurrently sharing process resources. Depending on the hardware, threads can run fully parallel if they are distributed to their own CPU core.

• Kubernetes.
• Hugo.
• CoreDNS.
• CockroachDB.
• Monzo Bank.

For the developer, Go makes it easy to package pieces of code functionality, and then build applications by assembling these packages. The packages can then be easily reused for other applications as well. And just as Go helps in development, it also makes life easier during deployment.

Constants can not be computed at runtime, their value must be known at compile time. That said, constants can be computed at compile-time, typically as a derivative of other constants.

The GOPATH environment variable is employed to symbolized directories out of $GOROOT that combines the source for Go projects including their binaries.

Godoc extracts package documentation from the source code that can be utilized on the command line or the web. An instance is golang.org/pkg/.

Go’s inherent features help enable the best practices for DevOps: immutable packages, testing, build promotion, security, etc. GoCenter is also a great resource for Go developers, providing always-available immutable access to dependencies with important metrics.

Unlike arrays, slices can be resized using the built-in append function. Further, slices are reference types, meaning that they are cheap to assign and can be passed to other functions without having to create a new copy of its underlying array.

• Arithmetic operators
• Bitwise operators
• Relational operators
• Logical operators
• Assignment operators
• Misc operators

It is used to check values that are held by interface type variable. It is also used to convert various GO types.

delete() function is used to delete an entry from the map. It requires map and corresponding key which is to be deleted.

In Go language, the select statement is just similar to a switch statement, however, in the select statement, the case statement indicates communication, i.e. sent or receive progress on the channel.

If you are programming on a 32 bit system then int, uint, and uintptr are usually 32 bits wide and 64 bits wide on 64-bit systems.

Strings are made of bytes or characters. GoLang uses bytes to define strings and uses UTF-8 encoding standard so any valid character can be defined using “code points” in Unicode. Rune is a new term in Go Language that represents this code point. Go uses UTF-8 encoding so type int32 can be aliased as Rune.

A string can be converted to an array of runes using Rune function. Rune and byte values are the same for ASCII characters.

The purpose of interfaces is to allow the computer to enforce these properties and to know that an object of TYPE T (whatever the interface is ) must have functions called X,Y,Z, etc.

It is used to achieve total abstraction. Since java does not support multiple inheritance in case of class, but by using interface it can achieve multiple inheritance . It is also used to achieve loose coupling.

No, Go doesn’t have exceptions. Golang’s multi-value returns make it easy to report errors without overloading the return value for plain error handling. Error-values are used to indicate an abnormal state in Go.

• For the buffered channel, the sender will block when there is an empty slot of the channel, while the receiver will block on the channel when it’s empty.
• Compared with the buffered counterpart, in an unbuffered channel, the sender will block the channel until the receiver receives the channel’s data. Simultaneously, the receiver will also block the channel until the sender sends data into the channel.

In GO, interfaces is a way to specify the behaviour of an object. An interface is created by using the “type” word, followed by a name and the keyword interface. An interface is specified as two things. A set of methods Also it is referred as type

A special type of switch is dedicated in GO to check variable type at runtime, this switch is referred as type switch. Also, you can switch on the type of an interface value with Type Switch.

The available built-in-support in GO includes

• Container: container/list , container/heap
• Web Server: net/http
• Cryptography: Crypto/md5 , crypto/sha1
• Compression: compress/ gzip
• Database: database/sql

Inside a workspace GO code must be kept. A workspace is a directory hierarchy with three directories at its root.

• src contains GO source files organized into packages
• pkg contains package objects and
• bin contains executable commands

Public is the default visibility for properties/methods in TypeScript classes.

In Go programming language there are several different types of functions called methods. In method declaration syntax, a “receiver” is used to to represent the container of the function. This receiver can be used to call function using “.” operator.

Rvalue

• Shows on assignment operator’s right side.
• Always assigned to lvalue.

Lvalue

• Shows on assignment operator’s left side.
• Designated to a variable and not a constant.

In Golang, the Cgo lets all the Go packages call a C code. With a Go source file written on some special features, the cgo makes an output in Go and C files which can be then combined into a single Go package bundle.

In Golang, a shadowed variable is one which is declared in an inner scope having the same name and type as a variable in the outer scope. Here, the outer variable is mentioned after the inner variable is declared.

In Golang, a channel is a communication object which uses goroutines to communicate with each other. Technically, it is a data transfer pipe in which data can be transferred into or read from.