Top 50 Golang Interview Questions & Answers

Preparing for a Go developer interview can feel challenging, especially with the language’s unique features and focus on concurrency. To help you navigate this, we’ve compiled a list of 50+ Golang interview questions along with clear answers and practical examples. Whether you’re a beginner or an experienced developer, this guide will give you the confidence to tackle real-world interview scenarios and stand out from the crowd

1. What are Goroutines in Go? How do they differ from threads?

Answer:
A goroutine is a lightweight, independently executing function managed by the Go runtime. They are much cheaper than threads because they use very little memory (a few KB) and are multiplexed onto OS threads by the Go scheduler.

Key Differences:

• Goroutines are managed by Go runtime, threads by OS.
• Goroutines start with a small stack (2 KB approx.) and grow dynamically. Threads have a fixed large stack.
• Millions of goroutines can run concurrently; threads are limited.

Example:

package main
import (
	"fmt"
	"time"
)

func printMsg(msg string) {
	for i := 0; i < 3; i++ {
		fmt.Println(msg)
		time.Sleep(500 * time.Millisecond)
	}
}

func main() {
	go printMsg("Hello") // run concurrently
	printMsg("World")
}

2. What are Channels in Go?

Answer:
Channels are communication pipelines that allow goroutines to communicate safely and synchronize without explicit locks.

Types:

• Unbuffered Channel → blocks until data is sent/received.
• Buffered Channel → allows limited storage before blocking.

Example:

package main
import "fmt"

func main() {
	ch := make(chan string) // unbuffered channel

	go func() {
		ch <- "Data sent!" // send
	}()

	msg := <-ch // receive
	fmt.Println(msg)
}

3. What is the difference between var, :=, and new() in Go?

Answer:

• var x int → declares with zero value.
• x := 10 → shorthand for declaration + initialization.
• new(T) → allocates memory, returns pointer to zeroed value of type T.

Example:

package main
import "fmt"

func main() {
	var a int       // default 0
	b := 20         // shorthand
	c := new(int)   // pointer to int
	fmt.Println(a, b, *c) // 0 20 0
}

4. Explain defer, panic, and recover in Go.

Answer:

• defer → delays execution of a function until the surrounding function returns.
• panic → stops normal execution (like exceptions).
• recover → regains control inside a deferred function after panic.

Example:

package main
import "fmt"

func safeDivide(a, b int) {
	defer func() {
		if r := recover(); r != nil {
			fmt.Println("Recovered:", r)
		}
	}()
	if b == 0 {
		panic("Divide by zero!")
	}
	fmt.Println("Result:", a/b)
}

func main() {
	safeDivide(10, 0)
	fmt.Println("Program continues...")
}

5. What is the difference between array and slice in Go?

Answer:

• Array → fixed size, part of type definition.
• Slice → dynamic, built on top of arrays, more flexible.

Example:

arr := [3]int{1, 2, 3}  // array
slc := []int{1, 2, 3}   // slice

Slices have length and capacity:

nums := []int{1, 2, 3, 4}
fmt.Println(len(nums), cap(nums)) // 4 4

6. How does Go handle memory management (Garbage Collection)?

Answer:
Go has a concurrent garbage collector (GC) that automatically frees unused memory.

• You don’t need free() or delete().
• GC runs concurrently with goroutines.
• Use slices/maps carefully to avoid memory leaks (unintended references).

Example:

package main
import "runtime"

func main() {
    m := make([]int, 1e6)
    _ = m
    runtime.GC() // manually trigger garbage collection
}

7. What are Go interfaces? How are they different from Java/C# interfaces?

Answer:
An interface in Go is a type that specifies method signatures.

• In Go, implementation is implicit → if a type has methods required by an interface, it automatically satisfies it (no implements keyword).

Example:

package main
import "fmt"

type Speaker interface {
	Speak() string
}

type Dog struct{}
func (Dog) Speak() string { return "Woof!" }

func main() {
	var s Speaker
	s = Dog{}
	fmt.Println(s.Speak())
}

8. What is the difference between Concurrency and Parallelism in Go?

Answer:

• Concurrency = managing multiple tasks at the same time (switching).
• Parallelism = executing multiple tasks simultaneously (requires multiple CPU cores).

Go supports concurrency with goroutines and parallelism via the GOMAXPROCS setting.

Example:

package main
import (
	"fmt"
	"runtime"
)

func main() {
	fmt.Println("CPUs:", runtime.NumCPU())
	runtime.GOMAXPROCS(2) // use 2 cores
}

9. What are Go Structs? How are they different from Classes in OOP?

Answer:

• A struct in Go is a collection of fields.
• Unlike classes, structs don’t have inheritance, but you can use composition.

Example:

type Person struct {
	Name string
	Age  int
}

func main() {
	p := Person{Name: "Alice", Age: 30}
	fmt.Println(p.Name, p.Age)
}

10. How do you handle errors in Go?

Answer:
Go uses explicit error handling instead of exceptions.

• Functions return value, error.
• Errors are checked with if err != nil.

Example:

package main
import (
	"fmt"
	"errors"
)

func divide(a, b int) (int, error) {
	if b == 0 {
		return 0, errors.New("cannot divide by zero")
	}
	return a/b, nil
}

func main() {
	res, err := divide(10, 0)
	if err != nil {
		fmt.Println("Error:", err)
	} else {
		fmt.Println("Result:", res)
	}
}

11. What is the difference between buffered and unbuffered channels?

Answer:

• Unbuffered channel → sender blocks until receiver is ready.
• Buffered channel → allows sending without an immediate receiver, up to its capacity.

Example:

ch := make(chan int, 2) // buffered
ch <- 1
ch <- 2
fmt.Println(<-ch, <-ch) // 1 2

12. What is the select statement in Go?

Answer:
select lets a goroutine wait on multiple channel operations. It chooses one that’s ready.

Example:

select {
case msg := <-ch1:
    fmt.Println("Received:", msg)
case msg := <-ch2:
    fmt.Println("From ch2:", msg)
default:
    fmt.Println("No channel ready")
}

13. What is the difference between value receiver and pointer receiver in methods?

Answer:

• Value receiver → works on a copy of the value (can’t modify original).
• Pointer receiver → works on the actual object (can modify).

Example:

type Counter struct{ val int }

func (c Counter) Add() { c.val++ }      // value receiver
func (c *Counter) Inc() { c.val++ }     // pointer receiver

c := Counter{}
c.Add()
fmt.Println(c.val) // 0 (not modified)
c.Inc()
fmt.Println(c.val) // 1 (modified)

14. Explain Go’s initialization order (package-level variables).

Answer:

• Package-level variables are initialized before main() runs.
• Init order:
  1. Imported packages
  2. Constants & variables
  3. init() functions

15. What is the init() function in Go?

Answer:

• A special function called automatically before main().
• Used for setup tasks (like database connection, environment check).
• A package can have multiple init() functions.

16. What are Variadic functions in Go?

Answer:
Functions that accept variable number of arguments.

Example:

func sum(nums ...int) int {
	total := 0
	for _, v := range nums {
		total += v
	}
	return total
}

fmt.Println(sum(1, 2, 3, 4)) // 10

17. How does Go support object-oriented programming (OOP)?

Answer:
Go has:

• Encapsulation → via exported/unexported fields.
• Composition → instead of inheritance.
• Polymorphism → via interfaces.
• No class keyword, only structs + methods.

18. What is the blank identifier _ in Go?

Answer:

• Used to ignore values (especially unused return values).

Example:

val, _ := someFunc() // ignore second return value

19. What is a rune in Go?

Answer:

• A rune is an alias for int32 representing a Unicode code point.
• Strings are UTF-8 encoded, so runes help handle multi-byte characters.

Example:

for _, r := range "Go💻" {
    fmt.Printf("%c ", r)
}
// Output: G o 💻

20. Explain Go’s memory escape analysis.

Answer:

• If a variable lives beyond its function scope, Go allocates it on the heap.
• Otherwise, it’s on the stack.
• Go compiler decides automatically.

21. What is a Go map? How is it implemented?

Answer:

• A map is a built-in hash table for key-value pairs.
• Average O(1) lookup and insert.
• Keys must be comparable (== and != must work).

Example:

m := map[string]int{"a": 1, "b": 2}
fmt.Println(m["a"]) // 1

22. Can you sort a map in Go?

Answer:
No, maps are unordered.
To sort: extract keys into a slice, sort, then iterate.

Example:

import "sort"

m := map[string]int{"b":2,"a":1}
keys := make([]string, 0, len(m))
for k := range m {
	keys = append(keys, k)
}
sort.Strings(keys)
for _, k := range keys {
	fmt.Println(k, m[k])
}

23. What is Go’s memory alignment and why is it important?

Answer:

• Go aligns struct fields to optimize memory access.
• Misaligned fields can cause padding (extra unused bytes).

Example:

type A struct {
	a byte
	b int32
	c byte
}
// may consume 12 bytes (due to padding)

24. What is embedding in Go?

Answer:

• Instead of inheritance, Go supports struct embedding (composition).

Example:

type Animal struct{ Name string }
func (a Animal) Speak() { fmt.Println("I am", a.Name) }

type Dog struct{ Animal }
d := Dog{Animal{"Dog"}}
d.Speak() // "I am Dog"

25. Difference between concurrency-safe and non-safe data structures in Go?

Answer:

• Maps are not safe for concurrent writes. Use sync.Map or locks.

Example:

import "sync"
var sm sync.Map
sm.Store("a", 1)
v, _ := sm.Load("a")
fmt.Println(v)

26. What is the difference between make() and new()?

Answer:

• new(T) → allocates memory for type T, returns *T.
• make() → used only for slices, maps, and channels (initializes internal data).

27. How does Go achieve cross-platform compilation?

Answer:

• By setting environment variables GOOS and GOARCH.

Example

GOOS=linux GOARCH=amd64 go build main.go

28. How do you prevent race conditions in Go?

Answer:

• Use channels for communication.
• Use mutex (sync.Mutex) for shared state.

Example:

import "sync"

var mu sync.Mutex
count := 0
mu.Lock()
count++
mu.Unlock()

29. What are Goroutine leaks? How to avoid them?

Answer:

• A goroutine leak occurs when goroutines are blocked forever (e.g., waiting on channels).
• Prevent by:
  • Closing channels properly.
  • Using context.Context for cancellation.

30. What is the difference between := and var?

Answer:

• := → shorthand, works inside functions only.
• var → works everywhere, allows zero-value initialization.

Example:

var x int   // allowed at package level
y := 10     // only allowed inside a function

31. Explain the memory model of Go. How does Go achieve safe concurrency?

Answer:

• Go uses a shared memory model with happens-before guarantees.
• Communication between goroutines is safe via channels and sync primitives.
• The Go memory model ensures that writes in one goroutine are visible to another only after proper synchronization (channel send/receive, sync.Mutex, sync/atomic).

32. What is the difference between sync.Mutex and sync.RWMutex?

Answer:

• sync.Mutex → only one goroutine can lock at a time.
• sync.RWMutex → multiple goroutines can hold a read lock simultaneously, but only one can hold a write lock.

Example:

var mu sync.RWMutex
mu.RLock()   // multiple readers allowed
mu.RUnlock()
mu.Lock()    // exclusive writer
mu.Unlock()

3. How does Go’s scheduler work?

Answer:

• Go uses an M:N scheduler → multiple goroutines (G) are multiplexed onto multiple OS threads (M), managed by logical processors (P).
• Scheduler decides which goroutines run on which OS thread.
• This is what makes goroutines extremely lightweight compared to threads.

34. What are the differences between sync.WaitGroup and sync.Once?

Answer:

• WaitGroup → waits for multiple goroutines to finish.
• Once → ensures a function is executed only once, no matter how many goroutines call it.

35. Explain the difference between shallow copy and deep copy in Go.

Answer:

• Shallow Copy: Copies references, not underlying data (e.g., slices, maps).
• Deep Copy: Copies entire underlying data manually.

36. How do you prevent memory leaks in Goroutines?

Answer:

• Always close channels when no longer needed.
• Use context.Context for cancellation.
• Avoid goroutines waiting forever (deadlocks).

Example (using context):

ctx, cancel := context.WithCancel(context.Background())
go func() {
	select {
	case <-ctx.Done():
		return
	}
}()
cancel()

37. Can you explain the difference between Go’s pass-by-value and pass-by-reference?

Answer:

• Everything in Go is pass-by-value.
• But when you pass a pointer, you pass a value that points to another memory location (reference-like behavior).

38. Why are slices considered references in Go?

Answer:
A slice internally has:

• A pointer to underlying array
• Length
• Capacity

When passed to a function, the pointer is copied → changes affect the original array.

39. How do you implement worker pools in Go?

Answer:
Use goroutines + channels.

Example:

jobs := make(chan int, 5)
results := make(chan int, 5)

for w := 1; w <= 3; w++ {
	go worker(w, jobs, results)
}

40. What is the difference between nil interface and typed nil interface in Go?

Answer:

• nil interface → interface value with no type and no value.
• typed nil interface → interface holds a type but value is nil.
  This causes confusion in error handling.

41. How do you implement generics in Go (Go 1.18+)?

Answer:
Generics allow defining functions & types with type parameters.

Example:

func Sum[T int | float64](a, b T) T {
	return a + b
}

42. What is the difference between stack and heap allocation in Go?

Answer:

• Stack: local variables (fast, auto cleanup).
• Heap: dynamically allocated, requires garbage collection.
  Escape analysis determines placement.

43. What is escape analysis in Go?

Answer:
Go compiler decides if a variable should be allocated on stack or heap.

• If a variable “escapes” function scope (returned or referenced in goroutine) → heap.

44. How does Go handle race conditions?

Answer:

• Go has a race detector (go run -race).
• Use sync.Mutex, sync/atomic, or channels to prevent races.

45. Explain the difference between new() and make() in Go.

Answer:

• new(T) → allocates zeroed memory for type T, returns pointer.
• make() → used only for slices, maps, and channels (initializes internal data structures).

46. How does Go handle function closures?

Answer:
Closures are functions that capture variables from the surrounding scope.

Example:

func counter() func() int {
	x := 0
	return func() int {
		x++
		return x
	}
}

47. How does Go handle reflection?

Answer:

• Package: reflect.
• Allows inspecting types and values at runtime.

Example:

import "reflect"
t := reflect.TypeOf(123) // int

48. What is the difference between runtime panic and compiler error in Go?

Answer:

• Compiler Error: caught at compile-time (syntax, type mismatch).
• Panic: runtime failure (nil pointer, out of range, divide by zero).

49. How do you implement context-based cancellation across multiple goroutines?

Answer:
Using context.WithCancel.

Example:

ctx, cancel := context.WithCancel(context.Background())
go func() {
	select {
	case <-ctx.Done():
		return
	}
}()
cancel()

50. How does Go implement interfaces under the hood?

Answer:

• An interface is implemented using a pair: (type, value).
• When a value is assigned to an interface, Go stores its type + pointer to value.
• That’s why a typed nil interface is not equal to nil.

Whether you’re a beginner learning the basics or an experienced developer polishing advanced topics, this guide covers everything you need to stand out in a Golang interview.”