34 Go Interview Questions To Crack In 2020 (Solved and Answered)
Tags: go, career, interview
Published: 2020-01-08 03:07:05

---
title: 34 Go Interview Questions To Crack In 2020 (Solved and Answered)
published: true
description: 34 Go Interview Questions To Crack In 2020 (Solved and Answered)
tags: #go #golang #career #interview
canonical_url: https://www.fullstack.cafe/blog/go-interview-questions
cover_image: https://images.pexels.com/photos/158826/structure-light-led-movement-158826.jpeg?auto=compress&cs=tinysrgb&dpr=2&w=500
---

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](https://www.fullstack.cafe/blog/go-interview-questions)

### Q1: What is Go?
> Topic: **Golang**<br/>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](https://www.tutorialspoint.com/go/go_interview_questions.htm)
### Q2: What are the benefits of using Go programming?
> Topic: **Golang**<br/>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](https://www.tutorialspoint.com/go/go_interview_questions.htm)
### Q3: What is static type declaration of a variable in Go?
> Topic: **Golang**<br/>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](https://www.tutorialspoint.com/go/go_interview_questions.htm)
### Q4: What is dynamic type declaration of a variable in Go?
> Topic: **Golang**<br/>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](https://www.tutorialspoint.com/go/go_interview_questions.htm)
### Q5: What is a pointer?
> Topic: **Golang**<br/>Difficulty: ⭐⭐

A **pointer variable** can hold the *address* of a variable.

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

Here `x` can be accessed by `*p`.

🔗 **Source:** [tutorialspoint.com](https://www.tutorialspoint.com/go/go_interview_questions.htm)
### Q6: Can you return multiple values from a function?
> Topic: **Golang**<br/>Difficulty: ⭐⭐

A Go function can return multiple values.

Consider:
```go
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](https://www.tutorialspoint.com/go/go_interview_questions.htm)
### Q7: What are some advantages of using Go?
> Topic: **Golang**<br/>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](https://golang.org/doc/faq)
### Q8: Why the Go language was created?
> Topic: **Golang**<br/>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](https://golang.org/doc/faq)
### Q9: Does Go have exceptions?
> Topic: **Golang**<br/>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:
```go
func Open(name string) (file *File, err error)
```
```go
f, err := os.Open("filename.ext")
if err != nil {
    log.Fatal(err)
}
// do something with the open *File f
```

🔗 **Source:** [golang.org](https://golang.org/doc/faq)
### Q10: What are Goroutines?
> Topic: **Golang**<br/>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](https://golangbot.com/goroutines/)
### Q11: What kind of type conversion is supported by Go?
> Topic: **Golang**<br/>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:
```go
i := 55      //int
j := 67.8    //float64
sum := i + int(j) //j is converted to int
```

🔗 **Source:** [golangbot.com](https://golangbot.com/types/)
### Q12: How to efficiently concatenate strings in Go?
> Topic: **Golang**<br/>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.

```go
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](https://stackoverflow.com/questions/1760757/how-to-efficiently-concatenate-strings/47798475#47798475)
### Q13: Explain this code
> Topic: **Golang**<br/>Difficulty: ⭐⭐

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

```go
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](https://stackoverflow.com/questions/23542989/pointers-vs-values-in-parameters-and-return-values)
### Q14: Have you worked with Go 2?
> Topic: **Golang**<br/>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](https://golang.org/doc/faq)
### Q15: Is Go an object-oriented language?
> Topic: **Golang**<br/>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:
```js
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](https://golangbot.com/goroutines/)
### Q16: What is "rune" type in Go?
> Topic: **Golang**<br/>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](https://golangbot.com/types/)
### Q17: What is so special about constants in Go?
> Topic: **Golang**<br/>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.
```go
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.
```go
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](https://www.callicoder.com/golang-typed-untyped-constants/)
### Q18: How to initialise a struct in Go?
> Topic: **Golang**<br/>Difficulty: ⭐⭐⭐

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

```go
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**.

```go
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](https://stackoverflow.com/questions/2976630/how-does-go-compile-so-quickly)
### Q19: How to check if a map contains a key in Go?
> Topic: **Golang**<br/>Difficulty: ⭐⭐⭐

```go
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](https://stackoverflow.com/questions/2050391/how-to-check-if-a-map-contains-a-key-in-go)
### Q20: Is there a foreach construct in the Go language?
> Topic: **Golang**<br/>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.

```go
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 `_`:
```go
for _, element := range someSlice {
    // element is the element from someSlice for where we are
}
```

🔗 **Source:** [stackoverflow.com](https://stackoverflow.com/questions/7782411/is-there-a-foreach-loop-in-go)
### Q21: Can Go have optional parameters? 
> Topic: **Golang**<br/>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](https://stackoverflow.com/questions/2032149/optional-parameters-in-go)
### Q22: What is the difference between the = and := operator? 
> Topic: **Golang**<br/>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](https://stackoverflow.com/questions/17891226/difference-between-and-operators-in-go)
### Q23: What are the differences between unbuffered and buffered channels?
> Topic: **Golang**<br/>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](https://goquiz.github.io/)
### Q24: Why would you prefer to use an empty struct{}?
> Topic: **Golang**<br/>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.

```go
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](https://goquiz.github.io/)
### Q25: How do you swap two values? Provide a few examples.
> Topic: **Golang**<br/>Difficulty: ⭐⭐⭐

Two values are swapped as easy as this:

```go
a, b = b, a
```

To swap three values, we would write:
```go
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](toptal.com)
### Q26: Implement a function that reverses a slice of integers
> Topic: **Golang**<br/>Difficulty: ⭐⭐⭐

```go
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](toptal.com)
### Q27: How to copy map in Go?
> Topic: **Golang**<br/>Difficulty: ⭐⭐⭐

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

```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](toptal.com)
### Q28: List the functions can stop or suspend the execution of current goroutine, and explain their differences.
> Topic: **Golang**<br/>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](https://goquiz.github.io/)
### Q29: What are the use(s) for tags in Go?
> Topic: **Golang**<br/>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:
```go
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:
```go
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](https://stackoverflow.com/questions/10858787/what-are-the-uses-for-tags-in-go)
### Q30: When is the init() function run?
> Topic: **Golang**<br/>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.

```go
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.

<div class="text-center"/>
<img src="https://astaxie.gitbooks.io/build-web-application-with-golang/en/images/2.3.init.png?raw=true" class="img-fluid" />
</div>


🔗 **Source:** [stackoverflow.com](https://stackoverflow.com/questions/24790175/when-is-the-init-function-run)
### Q31: How can I check if two slices are equal?
> Topic: **Golang**<br/>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`.

```go
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](https://stackoverflow.com/questions/15311969/checking-the-equality-of-two-slices)
### Q32: What might be wrong with the following small program?
> Topic: **Golang**<br/>Difficulty: ⭐⭐⭐⭐

```go 
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:

```go
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](https://www.toptal.com/go/interview-questions)
### Q33: When go runtime allocates memory from heap, and when from stack?
> Topic: **Golang**<br/>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](https://goquiz.github.io/)
### Q34: How to compare two interfaces in Go?
> Topic: **Golang**<br/>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:

```go
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:

```go
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](toptal.com)

> *Thanks 🙌 for reading and good luck on your interview!* <br/>*Please share this article with your fellow devs if you like it!* <br/>*Check more FullStack Interview Questions & Answers on 👉 [www.fullstack.cafe](https://www.fullstack.cafe)*