easyfor-range semantics
What does this loop print?
for _, r := range "abc" {
fmt.Printf("%c ", r)
}
// output?GO · PRACTICE
Go interview questions.
Go is built for concurrent network services. The runtime is small enough that interviews expect you to know how it behaves.
576questions
89easy
244medium
243hard
Goroutine leaks, channel and select semantics, nil interface versus nil pointer, escape analysis, context cancellation, and the garbage collector's pacing.
Where it shows up: Cloud infrastructure, platform teams, CLI tooling, and high-throughput API services.
Sample Go questions
Twenty real Go questions from the library, code snippet included. Nothing here is paraphrased for search engines. It is the same text a signed-in user sees.
easypackages and visibility
From another package that imports `mypkg`, which of these identifiers can be referenced?
package mypkg
var Total int
var count intmediumsync.Mutex and RWMutex
What happens when this code runs?
var mu sync.RWMutex
var data = map[string]int{"x": 1}
func read() int {
mu.RLock()
v := data["x"]
mu.Unlock()
return v
}mediumsync.WaitGroup
What does this print, and why?
var wg sync.WaitGroup
wg.Add(1)
go func() {
wg.Done()
wg.Done()
}()
wg.Wait()
fmt.Println("done")mediumsync.WaitGroup
What is the defect in this WaitGroup usage?
var wg sync.WaitGroup
for i := 0; i < 5; i++ {
go func() {
wg.Add(1)
defer wg.Done()
work()
}()
}
wg.Wait()mediumgenerics type parameters
Why does this call to the generic function not compile?
func Zeros[T any](n int) []T {
return make([]T, n)
}
func main() {
xs := Zeros(3)
_ = xs
}mediumpprof basics
Using `runtime/pprof`, you capture a CPU profile of a long-running job. Which statement correctly describes how a CPU profile is collected?
f, _ := os.Create("cpu.prof")
pprof.StartCPUProfile(f)
defer pprof.StopCPUProfile()mediumpprof basics
When importing `net/http/pprof` to expose profiles over HTTP, what does the blank import `_ "net/http/pprof"` actually accomplish?
import _ "net/http/pprof"mediumworker pool pattern
In the classic Go worker pool pattern below, why is `close(jobs)` important, and what happens if it is omitted?
jobs := make(chan int, 100)
var wg sync.WaitGroup
for w := 0; w < 3; w++ {
wg.Add(1)
go func() {
defer wg.Done()
for j := range jobs {
process(j)
}
}()
}
for _, j := range work {
jobs <- j
}
close(jobs)
wg.Wait()mediumreflection basics
When iterating struct fields with reflection to read a tag like `json:"name"`, which call gives you the parsed tag value, and what limitation applies to the fields you can read?
t := reflect.TypeOf(s)
f := t.Field(0)
tag := f.Tag.Get("json")hardescape analysis
In this code, where is the value pointed to by the returned pointer allocated, and why?
func newInt() *int {
x := 42
return &x
}hardempty interface eface layout
When the integer below is assigned to an empty interface, what does the eface's data word hold on a current gc-compiler build?
var x any = 7easystructs and tags
What is the purpose of the `json:"name"` tag in the struct field below?
type User struct {
Name string `json:"name"`
}mediumstruct embedding and promotion
Given the embedding below, what does d.Greet() print?
type Animal struct{}
func (Animal) Greet() string { return "Hi from Animal" }
type Dog struct{ Animal }
func (Dog) Greet() string { return "Hi from Dog" }
func main() {
d := Dog{}
fmt.Println(d.Greet())
}easyzero values
What does this print, given that the struct fields use their zero values?
type Config struct {
Name string
Retries int
Active bool
}
var c Config
fmt.Printf("%q %d %t", c.Name, c.Retries, c.Active)hardGo memory model
Given this code, what does the Go memory model say about whether the goroutine is guaranteed to observe a == 1?
var a int
c := make(chan struct{})
go func() {
a = 1
c <- struct{}{}
}()
<-c
print(a)easychannels send and receive
Using the comma-ok form on a receive, what does `ok` tell you?
v, ok := <-cheasystructs and tags
Given this struct tag, what JSON key is produced for the field?
type User struct {
Name string `json:"full_name"`
}
b, _ := json.Marshal(User{Name: "Ada"})
fmt.Println(string(b))easymaps and iteration
What happens when you call `delete` on a key that is not in the map?
m := map[string]int{"x": 1}
delete(m, "y")
fmt.Println(len(m))easypointers and receivers
What is the value of `p` after this code runs?
package main
func main() {
p := new(int)
_ = p
}Sign in to answer
Everything above is free to read. Answering needs a free account.
We keep the correct answer, the explanation and the scoring behind sign-in so the platform stays honest, which is why the answer options and the worked explanation for every Go question stay behind a free account. Signing in is free and takes a few seconds.
Go topics covered
60 distinct Go topics are tagged across the library. These are the real topic labels stored on the questions, not a hand-written list.
- pprof basics (23)
- channel internals hchan sudog (23)
- errgroup and fan-out (20)
- table-driven tests (19)
- benchmarks (17)
- context cancel deadline values (16)
- reflection basics (16)
- goroutine preemption (16)
- write barriers and GC pacing (16)
- map internals buckets growth (15)
- sync.Mutex and RWMutex (15)
- sync.WaitGroup (15)
- generics type parameters (15)
- interface representation iface itab (15)
- type constraints and comparable (14)
- escape analysis (14)
- empty interface eface layout (14)
- worker pool pattern (12)
- struct embedding and promotion (12)
- netpoll integration (12)
- graceful shutdown (11)
- cgo call cost (11)
- error values and wrapping (10)
- GC tri-color mark-sweep (10)
- defer panic recover mechanics (10)
- goroutine stack growth (10)
- the GMP scheduler (10)
- sync/atomic and memory ordering (10)
- slices and slice growth (9)
- sync.Once and sync.Pool (9)
- GMP scheduler (9)
- functional options pattern (9)
- inlining rules (9)
- Go memory model (8)
- the race detector (8)
- slice header aliasing pitfalls (8)
- maps and iteration (7)
- structs and tags (7)
- channels send and receive (7)
- iota and typed enums (7)
- Go memory model and happens-before (7)
- goroutines basics (6)
- buffered vs unbuffered channels (6)
- errors.Is and errors.As (6)
- for-range semantics (5)
- packages and visibility (5)
- the Go memory model and happens-before (5)
- select statement (4)
- interfaces and satisfaction (4)
- methods on types (4)
- channel direction types (4)
- pointers and receivers (3)
- defer (3)
- zero values (3)
- variadic functions (3)
- range over channels (3)
- sync.Pool (3)
- write barriers (2)
- sync.Once (1)
- Channel internals (hchan, sudog) (1)
Search and filter every Go question
…
Difficulty