Top 49 Golang Interview Questions And Answers

Question 1

Is Go a new language, framework or library?

Accepted Answer

**Go** isn't a library and not a framework, it's a new language.

Go is mostly in the C family (basic syntax), with significant input from the Pascal/Modula/Oberon family (declarations, packages). Go does have an extensive library, called the runtime, that is part of every Go program. Although it is more central to the language, Go's runtime is analogous to libc, the C library. It is important to understand, however, that Go's runtime does not include a virtual machine, such as is provided by the Java runtime. Go programs are compiled ahead of time to native machine code.

Question 2

What is Go?

Accepted Answer

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

Question 3

What kind of _type conversion_ is supported by Go?

Accepted Answer

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

Question 4

Does Go have _exceptions_?

Accepted Answer

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

Question 5

Why the Go language was created?

Accepted Answer

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

Question 6

What are some advantages of using Go?

Accepted Answer

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

Question 7

What are _Goroutines_?

Accepted Answer

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

Question 8

What is a _pointer_?

Accepted Answer

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

Question 9

What are the benefits of using Go programming?

Accepted Answer

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.

Question 10

Can you _declared multiple types of variables_ in single declaration in Go?

Accepted Answer

Yes. Variables of different types can be declared in one go using type inference.

```go
var a, b, c =  3,  4,  "foo"  
```

Top 49 Golang Interview Questions

What is Go?

Is Go a new language, framework or library?

What is a pointer?

Does Go have exceptions?

What are Goroutines?

Why the Go language was created?

Can you declared multiple types of variables in single declaration in Go?

What are the benefits of using Go programming?

What kind of type conversion is supported by Go?

What are some advantages of using Go?

What is static type declaration of a variable in Go?

How to efficiently concatenate strings in Go?

Can you return multiple values from a function?

What is dynamic type declaration of a variable in Go?

How to check if a Map contains a key in Go?

Can Go have optional parameters?

What is rune type in Go?

What would you do if you need a hash displayed in a fixed order?

What are the differences between unbuffered and buffered channels?

What is the preferred way to handle configuration parameters for a Go program?

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

How to initialise a struct in Go?

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

Is there a foreach construct in the Go language?

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

Have you worked with Go 2?

How to copy Map in Go?

What is the difference between C.sleep() and time.Sleep()?

Name some advantages of Goroutines over threads

What is so special about constants in Go?

Is Go an object-oriented language?

How to find a type of an object in Go?

How can I check if two slices are equal?

How does Go compile so quickly?

Briefly describe how GC works in GO

What is an idiomatic way of representing enums in Go?

What is $GOROOT and $GOPATH?

What is the difference, if any, in the following two slice declarations, and which one is more preferable?

When is the init() function run?

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

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

How to compare two interfaces in Go?

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

What is the malloc threshold of Map object? How to modify it?

Explain this code

Let's talk variable declaration in Go. Could you explain what is a variable zero value?

Implement a function that reverses a slice of integers

What might be wrong with the following small program?

What is the idiomatic Go equivalent of C's ternary operator?

How to check if a `Map` contains a `key` in Go?

What is `rune` type in Go?

What would you do if you need a `hash` displayed in a fixed order?

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

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

Is there a `foreach` construct in the Go language?

How to copy `Map` in Go?

What is the difference between `C.sleep()` and `time.Sleep()`?

What is `$GOROOT` and `$GOPATH`?

When is the `init()` function run?

What is the `malloc` threshold of `Map` object? How to modify it?

Let's talk variable declaration in Go. Could you explain what is a variable `zero value`?