Go hits the very sweet spot of performance and speedy development. It takes some elements from dynamic languages like Python and couples them with static typing at compile time and according ZipRecruiter Golang Developer Annual Salary in US is $125,851. Follow along to check 34 Go interview questions you will be asked to crack in 2020.

Originally published on FullStack.Cafe - Real Tech Interview Questions And Answers For Devs

Q1: What is Go?

Topic: Golang
Difficulty: ⭐

Go is a general-purpose language designed with systems programming in mind. It was initially developed at Google in year 2007 by Robert Griesemer, Rob Pike, and Ken Thompson. It is strongly and statically typed, provides inbuilt support for garbage collection and supports concurrent programming. Programs are constructed using packages, for efficient management of dependencies. Go programming implementations use a traditional compile and link model to generate executable binaries.

🔗 Source: tutorialspoint.com

Q2: What are the benefits of using Go programming?

Topic: Golang
Difficulty: ⭐⭐

Following are the benefits of using Go programming:

• Support for environment adopting patterns similar to dynamic languages. For example type inference (x := 0 is valid declaration of a variable x of type int).
• Compilation time is fast.
• In built concurrency support: light-weight processes (via goroutines), channels, select statement.
• Conciseness, Simplicity, and Safety.
• Support for Interfaces and Type embedding.
• The go compiler supports static linking. All the go code can be statically linked into one big fat binary and it can be deployed in cloud servers easily without worrying about dependencies.

🔗 Source: tutorialspoint.com

Q3: What is static type declaration of a variable in Go?

Topic: Golang
Difficulty: ⭐⭐

Static type variable declaration provides assurance to the compiler that there is one variable existing with the given type and name so that compiler proceed for further compilation without needing complete detail about the variable. A variable declaration has its meaning at the time of compilation only, compiler needs actual variable declaration at the time of linking of the program.

🔗 Source: tutorialspoint.com

Q4: What is dynamic type declaration of a variable in Go?

Topic: Golang
Difficulty: ⭐⭐

A dynamic type variable declaration requires compiler to interpret the type of variable based on value passed to it. Compiler don't need a variable to have type statically as a necessary requirement.

🔗 Source: tutorialspoint.com

Q5: What is a pointer?

Topic: Golang
Difficulty: ⭐⭐

A pointer variable can hold the address of a variable.

Consider:

var x =  5  var p *int p =  &x
fmt.Printf("x = %d",  *p)

Here x can be accessed by *p.

🔗 Source: tutorialspoint.com

Q6: Can you return multiple values from a function?

Topic: Golang
Difficulty: ⭐⭐

A Go function can return multiple values.

Consider:

package main
import "fmt"

func swap(x, y string) (string, string) {
   return y, x
}
func main() {
   a, b := swap("Mahesh", "Kumar")
   fmt.Println(a, b)
}

🔗 Source: tutorialspoint.com

Q7: What are some advantages of using Go?

Topic: Golang
Difficulty: ⭐⭐

Go is an attempt to introduce a new, concurrent, garbage-collected language with fast compilation and the following benefits:

• It is possible to compile a large Go program in a few seconds on a single computer.
• Go provides a model for software construction that makes dependency analysis easy and avoids much of the overhead of C-style include files and libraries.
• Go's type system has no hierarchy, so no time is spent defining the relationships between types. Also, although Go has static types, the language attempts to make types feel lighter weight than in typical OO languages.
• Go is fully garbage-collected and provides fundamental support for concurrent execution and communication.
• By its design, Go proposes an approach for the construction of system software on multicore machines.

🔗 Source: golang.org

Q8: Why the Go language was created?

Topic: Golang
Difficulty: ⭐⭐

Go was born out of frustration with existing languages and environments for systems programming.

Go is an attempt to have:

• an interpreted, dynamically typed language with
• the efficiency and safety of a statically typed, compiled language
• support for networked and multicore computing
• be fast in compilation

To meet these goals required addressing a number of linguistic issues: an expressive but lightweight type system; concurrency and garbage collection; rigid dependency specification; and so on. These cannot be addressed well by libraries or tools so a new language was born.

🔗 Source: golang.org

Q9: Does Go have exceptions?

Topic: Golang
Difficulty: ⭐⭐

No, Go takes a different approach. For plain error handling, Go's multi-value returns make it easy to report an error without overloading the return value. Go code uses error values to indicate an abnormal state.

Consider:

func Open(name string) (file *File, err error)

f, err := os.Open("filename.ext")
if err != nil {
    log.Fatal(err)
}
// do something with the open *File f

🔗 Source: golang.org

Q10: What are Goroutines?

Topic: Golang
Difficulty: ⭐⭐

Goroutines are functions or methods that run concurrently with other functions or methods. Goroutines can be thought of as light weight threads. The cost of creating a Goroutine is tiny when compared to a thread. Its common for Go applications to have thousands of Goroutines running concurrently.

🔗 Source: golangbot.com

Q11: What kind of type conversion is supported by Go?

Topic: Golang
Difficulty: ⭐⭐

Go is very strict about explicit typing. There is no automatic type promotion or conversion. Explicit type conversion is required to assign a variable of one type to another.

Consider:

i := 55      //int
j := 67.8    //float64
sum := i + int(j) //j is converted to int

🔗 Source: golangbot.com

Q12: How to efficiently concatenate strings in Go?

Topic: Golang
Difficulty: ⭐⭐

In Go, a string is a primitive type, which means it is read-only, and every manipulation of it will create a new string.

So if I want to concatenate strings many times without knowing the length of the resulting string, what's the best way to do it?

Beginning with Go 1.10 there is a strings.Builder. A Builder is used to efficiently build a string using Write methods. It minimizes memory copying. The zero value is ready to use.

package main

import (
    "strings"
    "fmt"
)

func main() {
    var str strings.Builder

    for i := 0; i < 1000; i++ {
        str.WriteString("a")
    }

    fmt.Println(str.String())
}

🔗 Source: stackoverflow.com

Q13: Explain this code

Topic: Golang
Difficulty: ⭐⭐

In Go there are various ways to return a struct value or slice thereof. Could you explain the difference?

type MyStruct struct {
    Val int
}

func myfunc() MyStruct {
    return MyStruct{Val: 1}
}

func myfunc() *MyStruct {
    return &MyStruct{}
}

func myfunc(s *MyStruct) {
    s.Val = 1
}

Shortly:

• the first returns a copy of the struct,
• the second a pointer to the struct value created within the function,
• the third expects an existing struct to be passed in and overrides the value.

🔗 Source: stackoverflow.com

Q14: Have you worked with Go 2?

Topic: Golang
Difficulty: ⭐⭐⭐

Tricky questions and the answer is no one worked. There is no Go version 2 available in 2018 but there are some movement toward it. Go 1 was released in 2012, and includes a language specification, standard libraries, and custom tools. It provides a stable foundation for creating reliable products, projects, and publications. The purpose of Go 1 is to provide long-term stability. There may well be a Go 2 one day, but not for a few years and it will be influenced by what we learn using Go 1 as it is today.

The possible goals and features of Go 2 are:

• Fix the most significant ways Go fails to scale *Provide backward compatibility
• Go 2 must not split the Go ecosystem

🔗 Source: golang.org

Q15: Is Go an object-oriented language?

Topic: Golang
Difficulty: ⭐⭐⭐

Yes and no. Although Go has types and methods and allows an object-oriented style of programming, there is no type hierarchy. This is in contrast to most object-oriented languages like C++, Java, C#, Scala, and even dynamic languages like Python and Ruby.

Go Object-Oriented Language Features:

• Structs - Structs are user-defined types. Struct types (with methods) serve similar purposes to classes in other languages.
• Methods - Methods are functions that operate on particular types. They have a receiver clause that mandates what type they operate on.
• Embedding - we can embed anonymous types inside each other. If we embed a nameless struct then the embedded struct provides its state (and methods) to the embedding struct directly.
• Interfaces - Interfaces are types that declare sets of methods. Similarly to interfaces in other languages, they have no implementation. Objects that implement all the interface methods automatically implement the interface. There is no inheritance or subclassing or "implements" keyword.

The Go way to implement:

• ** Encapsulation** - Go encapsulates things at the package level. Names that start with a lowercase letter are only visible within that package. You can hide anything in a private package and just expose specific types, interfaces, and factory functions.
• Inheritance - composition by embedding an anonymous type is equivalent to implementation inheritance.
• Polymorphism - A variable of type interface can hold any value which implements the interface. This property of interfaces is used to achieve polymorphism in Go.

Consider:

package main

import (  
    "fmt"
)

// interface declaration
type Income interface {  
    calculate() int
    source() string
}

// struct declaration
type FixedBilling struct {  
    projectName string
    biddedAmount int
}

type TimeAndMaterial struct {  
    projectName string
    noOfHours  int
    hourlyRate int
}

// interface implementation for FixedBilling
func (fb FixedBilling) calculate() int {  
    return fb.biddedAmount
}

func (fb FixedBilling) source() string {  
    return fb.projectName
}

// interface implementation for TimeAndMaterial
func (tm TimeAndMaterial) calculate() int {  
    return tm.noOfHours * tm.hourlyRate
}

func (tm TimeAndMaterial) source() string {  
    return tm.projectName
}

// using Polymorphism for calculation based 
// on the array of variables of interface type 
func calculateNetIncome(ic []Income) {  
    var netincome int = 0
    for _, income := range ic {
        fmt.Printf("Income From %s = $%d\n", income.source(), income.calculate())
        netincome += income.calculate()
    }
    fmt.Printf("Net income of organisation = $%d", netincome)
}

func main() {  
    project1 := FixedBilling{projectName: "Project 1", biddedAmount: 5000}
    project2 := FixedBilling{projectName: "Project 2", biddedAmount: 10000}
    project3 := TimeAndMaterial{projectName: "Project 3", noOfHours: 160, hourlyRate: 25}
    incomeStreams := []Income{project1, project2, project3}
    calculateNetIncome(incomeStreams)
}

🔗 Source: golangbot.com

Q16: What is "rune" type in Go?

Topic: Golang
Difficulty: ⭐⭐⭐

There are many other symbols invented by humans other than the 'abcde..' symbols. And there are so many that we need 32 bit to encode them.

A rune is a builtin type in Go and it's the alias of int32. rune represents a Unicode CodePoint in Go. It does not matter how many bytes the code point occupies, it can be represented by a rune. For example the rule literal a is in reality the number 97.

A string is not necessarily a sequence of runes. We can convert between string and []rune, but they are different.

🔗 Source: golangbot.com

Q17: What is so special about constants in Go?

Topic: Golang
Difficulty: ⭐⭐⭐

Constants in Go are special.

• Untyped constants. Any constant in golang, named or unnamed, is untyped unless given a type explicitly. For example an untyped floating-point constant like 4.5 can be used anywhere a floating-point value is allowed. We can use untyped constants to temporarily escape from Go’s strong type system until their evaluation in a type-demanding expression.

1       // untyped integer constant
const a = 1
var myFloat32 float32 = 4.5
var myComplex64 complex64 = 4.5

• Typed constants. Constants are typed when you explicitly specify the type in the declaration. With typed constants, you lose all the flexibility that comes with untyped constants like assigning them to any variable of compatible type or mixing them in mathematical operations.

const typedInt int = 1  

Generally we should declare a type for a constant only if it’s absolutely necessary. Otherwise, just declare constants without a type.

🔗 Source: callicoder.com

Q18: How to initialise a struct in Go?

Topic: Golang
Difficulty: ⭐⭐⭐

The new keyword can be used to create a new struct. It returns a pointer to the newly created struct.

var pa *Student   // pa == nil
pa = new(Student) // pa == &Student{"", 0}
pa.Name = "Alice" // pa == &Student{"Alice", 0}

You can also create and initialize a struct with a struct literal.

b := Student{ // b == Student{"Bob", 0}
    Name: "Bob",
}

pb := &Student{ // pb == &Student{"Bob", 8}
    Name: "Bob",
    Age:  8,
}

c := Student{"Cecilia", 5} // c == Student{"Cecilia", 5}
d := Student{}             // d == Student{"", 0}

🔗 Source: stackoverflow.com

Q19: How to check if a map contains a key in Go?

Topic: Golang
Difficulty: ⭐⭐⭐

if val, ok := dict["foo"]; ok {
    //do something here
}

if statements in Go can include both a condition and an initialization statement. The example above uses both:

• initializes two variables - val will receive either the value of "foo" from the map or a "zero value" (in this case the empty string) and ok will receive a bool that will be set to true if "foo" was actually present in the map

• evaluates ok, which will be true if "foo" was in the map

If "foo" is indeed present in the map, the body of the if statement will be executed and val will be local to that scope.

🔗 Source: stackoverflow.com

Q20: Is there a foreach construct in the Go language?

Topic: Golang
Difficulty: ⭐⭐⭐

A for statement with a range clause iterates through all entries of an array, slice, string or map, or values received on a channel. For each entry it assigns iteration values to corresponding iteration variables and then executes the block.

for index, element := range someSlice {
    // index is the index where we are
    // element is the element from someSlice for where we are
}

If you don't care about the index, you can use _:

for _, element := range someSlice {
    // element is the element from someSlice for where we are
}

🔗 Source: stackoverflow.com

Q21: Can Go have optional parameters?

Topic: Golang
Difficulty: ⭐⭐⭐

Or can I just define two functions with the same name and a different number of arguments?

Go does not have optional parameters nor does it support method overloading:

Method dispatch is simplified if it doesn't need to do type matching as well. Experience with other languages told us that having a variety of methods with the same name but different signatures was occasionally useful but that it could also be confusing and fragile in practice. Matching only by name and requiring consistency in the types was a major simplifying decision in Go's type system.

🔗 Source: stackoverflow.com

Q22: What is the difference between the = and := operator?

Topic: Golang
Difficulty: ⭐⭐⭐

In Go, := is for declaration + assignment, whereas = is for assignment only.

For example, var foo int = 10 is the same as foo := 10.

🔗 Source: stackoverflow.com

Q23: What are the differences between unbuffered and buffered channels?

Topic: Golang
Difficulty: ⭐⭐⭐

• For unbuffered channel, the sender will block on the channel until the receiver receives the data from the channel, whilst the receiver will also block on the channel until sender sends data into the channel.
• Compared with unbuffered counterpart, the sender of buffered channel will block when there is no empty slot of the channel, while the receiver will block on the channel when it is empty.

🔗 Source: goquiz.github.io

Q24: Why would you prefer to use an empty struct{}?

Topic: Golang
Difficulty: ⭐⭐⭐

You would use an empty struct when you would want to save some memory. Empty structs do not take any memory for its value.

a := struct{}{}
println(unsafe.Sizeof(a))
// Output: 0

This saving is usually insignificant and is dependent on the size of the slice or a map. Although, more important use of an empty struct is to show a reader you do not need a value at all. Its purpose in most cases is mainly informational.

🔗 Source: goquiz.github.io

Q25: How do you swap two values? Provide a few examples.

Topic: Golang
Difficulty: ⭐⭐⭐

Two values are swapped as easy as this:

a, b = b, a

To swap three values, we would write:

a, b, c = b, c, a

The swap operation in Go is guaranteed from side effects. The values to be assigned are guaranteed to be stored in temporary variables before starting the actual assigning, so the order of assignment does not matter.

🔗 Source: https://www.toptal.com/go/interview-questions

Q26: Implement a function that reverses a slice of integers

Topic: Golang
Difficulty: ⭐⭐⭐

func reverse(s []int) {
        for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
                s[i], s[j] = s[j], s[i]
        }
}

func main() {
    a := []int{1, 2, 3}
    reverse(a)
    fmt.Println(a)
    // Output: [3 2 1]
}

🔗 Source: https://www.toptal.com/go/interview-questions

Q27: How to copy map in Go?

Topic: Golang
Difficulty: ⭐⭐⭐

You copy a map by traversing its keys. Unfortunately, this is the simplest way to copy a map in Go:

a := map[string]bool{"A": true, "B": true}
b := make(map[string]bool)
for key, value := range a {
    b[key] = value
}

🔗 Source: https://www.toptal.com/go/interview-questions

Q28: List the functions can stop or suspend the execution of current goroutine, and explain their differences.

Topic: Golang
Difficulty: ⭐⭐⭐⭐

• runtime.Gosched: give up CPU core and join the queue, thus will be executed automatically.
• runtime.gopark: blocked until the callback function unlockf in argument list return false.
• runtime.notesleep: hibernate the thread.
• runtime.Goexit: stop the execution of goroutine immediately and call defer, but it will not cause panic.

🔗 Source: goquiz.github.io

Q29: What are the use(s) for tags in Go?

Topic: Golang
Difficulty: ⭐⭐⭐⭐

A tag for a field allows you to attach meta-information to the field which can be acquired using reflection. Usually it is used to provide transformation info on how a struct field is encoded to or decoded from another format (or stored/retrieved from a database), but you can use it to store whatever meta-info you want to, either intended for another package or for your own use.

Consider:

type User struct {
    Name  string `mytag:"MyName"`
    Email string `mytag:"MyEmail"`
}

u := User{"Bob", "bob@mycompany.com"}
t := reflect.TypeOf(u)

for _, fieldName := range []string{"Name", "Email"} {
    field, found := t.FieldByName(fieldName)
    if !found {
        continue
    }
    fmt.Printf("\nField: User.%s\n", fieldName)
    fmt.Printf("\tWhole tag value : %q\n", field.Tag)
    fmt.Printf("\tValue of 'mytag': %q\n", field.Tag.Get("mytag"))
}

Output:

Field: User.Name
    Whole tag value : "mytag:\"MyName\""
    Value of 'mytag': "MyName"

Field: User.Email
    Whole tag value : "mytag:\"MyEmail\""
    Value of 'mytag': "MyEmail"

🔗 Source: stackoverflow.com

Q30: When is the init() function run?

Topic: Golang
Difficulty: ⭐⭐⭐⭐

init() is called after all the variable declarations in the package have evaluated their initializers, and those are evaluated only after all the imported packages have been initialized.

If a package has one or more init() functions they are automatically executed before the main package's main() function is called.

import --> const --> var --> init()

• If a package imports other packages, the imported packages are initialized first.
• Current package's constant initialized then.
• Current package's variables are initialized then.
• Finally, init() function of current package is called.

🔗 Source: stackoverflow.com

Q31: How can I check if two slices are equal?

Topic: Golang
Difficulty: ⭐⭐⭐⭐

You need to loop over each of the elements in the slice and test. Equality for slices is not defined. However, there is a bytes.Equal function if you are comparing values of type []byte.

func testEq(a, b []Type) bool {

    // If one is nil, the other must also be nil.
    if (a == nil) != (b == nil) { 
        return false; 
    }

    if len(a) != len(b) {
        return false
    }

    for i := range a {
        if a[i] != b[i] {
            return false
        }
    }

    return true
}

We also could use reflect.DeepEqual(). Slice values are deeply equal when all of the following are true: they are both nil or both non-nil, they have the same length, and either they point to the same initial entry of the same underlying array (that is, &x[0] == &y[0]) or their corresponding elements (up to length) are deeply equal. Note that a non-nil empty slice and a nil slice (for example, []byte{} and []byte(nil)) are not deeply equal.

🔗 Source: stackoverflow.com

Q32: What might be wrong with the following small program?

Topic: Golang
Difficulty: ⭐⭐⭐⭐

func main() {
    scanner := bufio.NewScanner(strings.NewReader(`one
two
three
four
`))
    var (
        text string
        n    int
    )
    for scanner.Scan() {
        n++
        text += fmt.Sprintf("%d. %s\n", n, scanner.Text())
    }
    fmt.Print(text)

    // Output:
    // 1. One
    // 2. Two
    // 3. Three
    // 4. Four
}

The program numbers the lines in a buffer and uses the text/scanner to read the input line-by-line. What might be wrong with it?

First, it is not necessary to collect the input in the string before putting it out to standard output. This example is slightly contrived.

Second, the string text is not modified with the += operator, it is created anew for every line. This is a significant difference between strings and []byte slices — strings in Go are non-modifiable. If you need to modify a string, use a []byte slice.

Here’s a provided small program, written in a better way:

func main() {
    scanner := bufio.NewScanner(strings.NewReader(`one
two
three
four
`))
    var (
        text []byte
        n    int
    )
    for scanner.Scan() {
        n++
        text = append(text, fmt.Sprintf("%d. %s\n", n, scanner.Text())...)
    }
    os.Stdout.Write(text)
    // 1. One
    // 2. Two
    // 3. Three
    // 4. Four
}

That is the point of the existence of both bytes and strings packages.

🔗 Source: toptal.com

Q33: When go runtime allocates memory from heap, and when from stack?

Topic: Golang
Difficulty: ⭐⭐⭐⭐⭐

Stack memory is allocated:

• For small objects whose life cycle is only within the stack frame
• For small objects that could escape to heap but actually inlined

Heap memory is allocated:

• For small objects that will be passed across stack frames
• For big objects (>32KB)

🔗 Source: goquiz.github.io

Q34: How to compare two interfaces in Go?

Topic: Golang
Difficulty: ⭐⭐⭐⭐⭐

You can compare two interfaces with the == operator as long as the underlying types are “simple” and identical. Otherwise the code will panic at runtime:

var a interface{}
var b interface{}

a = 10
b = 10
println(a == b)
// Output: true

a = []int{1}
b = []int{2}
println(a == b)
// Output: panic: runtime error: comparing uncomparable type []int

Both structs and interfaces which contain maps, slices (but not functions) can be compared with the reflect.DeepEqual() function:

var a interface{}
var b interface{}

a = []int{1}
b = []int{1}
println(reflect.DeepEqual(a, b))
// Output: true

a = map[string]string{"A": "B"}
b = map[string]string{"A": "B"}
println(reflect.DeepEqual(a, b))
// Output: true

temp := func() {}
a = temp
b = temp
println(reflect.DeepEqual(a, b))
// Output: false

🔗 Source: https://www.toptal.com/go/interview-questions

Thanks 🙌 for reading and good luck on your interview!
Please share this article with your fellow devs if you like it!
Check more FullStack Interview Questions & Answers on 👉 www.fullstack.cafe