38 Go interview questions on tricky output & code-review puzzles, with detailed answers and code.
func main() { var wg sync.WaitGroup var ptrs []*int for i := 0; i < 3; i++ { ptrs = append(ptrs, &i) wg.Add(1) go func() { defer wg.Done() fmt.Print(i, " ") }() }…
for i := 0; i < 5; i++ { i++ fmt.Print(i, " ") } fmt.Println() for i := range 5 { i++ fmt.Print(i, " ") } The first prints 1 3 5 . The second prints 1 2 3 4 5 . In a…
func order() { for i := range 3 { defer fmt.Print(i, " ") } fmt.Print("end ") } func processAll(paths []string) error { for _, p := range paths { f, err := os.Open(p) if…
func main() { x := 1 defer fmt.Println("a", x) defer func() { fmt.Println("b", x) }() x = 2 } Output: b 2 a 1 The function value and arguments of a deferred call are…
func f() (r int) { defer func() { r *= 2 }() return 3 } func g() int { r := 3 defer func() { r *= 2 }() return r } func h() (r int) { defer func() { r *= 2 }() r = 1…
a := make([]int, 3, 10) b := append(a, 1) c := append(a, 2) fmt.Println(a, b, c) fmt.Println(len(a), len(b), cap(b)) Output: [0 0 0] [0 0 0 2] [0 0 0 2] 3 4 10 a has…
func modify(s []int) { s[0] = 99 s = append(s, 4) s[1] = 42 } func main() { x := []int{1, 2, 3} // len 3, cap 3 modify(x) fmt.Println(x) // ? y := make([]int, 3, 4) //…
func header(path string) ([]byte, error) { data, err := os.ReadFile(path) // e.g. 500 MB if err != nil { return nil, err } return data[:64], nil // keeps all 500 MB…
arr := [3]int{1, 2, 3} for i, v := range arr { if i == 0 { arr[1] = 100 } fmt.Print(v, " ") } fmt.Println(arr) sl := []int{1, 2, 3} for i, v := range sl { if i == 0 {…
type User struct { Name string Age int } users := []User{{"ann", 30}, {"bob", 40}} for _, u := range users { u.Age++ } fmt.Println(users) // [{ann 30} {bob 40}] u is a…
type MyErr struct{ msg string } func (e *MyErr) Error() string { return "myerr" } func do(fail bool) error { var p *MyErr if fail { p = &MyErr{"bad"} } return p // BUG }…
type Shape interface{ Area() float64 } type Square struct{ side float64 } func (s *Square) Area() float64 { return s.side * s.side } func main() { var s Shape =…
type T struct{ n int } func (t T) Val() { fmt.Println("val", t.n) } func (t *T) Ptr() { fmt.Println("ptr", t.n) } func main() { t := T{1} v := t.Val // method value p :=…
type Counter struct { mu sync.Mutex n int } func (c Counter) Inc() { // BUG: value receiver c.mu.Lock() defer c.mu.Unlock() c.n++ } func (c Counter) Value() int { return…
m := map[int]bool{1: true, 2: true, 3: true} for k := range m { m[k+10] = true } fmt.Println(len(m)) // ? for k := range m { if k > 5 { delete(m, k) // safe } } The…
type stat struct{ count int } m := map[string]stat{"a": {}} m["a"].count++ // compile error: cannot assign to struct field m["a"].count in map var nm map[string]int…
func parse(s string) (int, error) { var n int var err error if s != "" { n, err := strconv.Atoi(s) // := declares NEW n and err if err != nil { log.Println("inner:",…
func worker(id int, wg sync.WaitGroup) { // BUG 2: copied defer wg.Done() fmt.Println("worker", id) } func main() { var wg sync.WaitGroup for i := range 3 { go func() {…
func merge(a, b <-chan int, out chan<- int) { for { select { case v := <-a: out <- v case v := <-b: out <- v } } } A receive from a closed channel is always ready and…
a := make(chan int, 1) b := make(chan int, 1) a <- 1 b <- 2 select { case v := <-a: fmt.Println("a", v) case v := <-b: fmt.Println("b", v) } ticker := time.NewTicker(10…
This table comes up in almost every senior interview: Operation nil channel open channel closed channel send ch<-v blocks forever blocks/succeeds PANIC: send on closed…
// A ch := make(chan int) ch <- 1 // no receiver can ever run fmt.Println(<-ch) // B ch2 := make(chan int) go func() { for i := range 3 { ch2 <- i } // forgot close(ch2)…
var msg string func main() { c := make(chan int) // unbuffered go func() { msg = "hello" <-c // receive }() c <- 0 // send fmt.Println(msg) } Yes, with an unbuffered…
func fetchWithTimeout(ctx context.Context) (string, error) { ch := make(chan string) // BUG: unbuffered go func() { ch <- slowFetch() // blocks forever if nobody…
func handle() { if r := recover(); r != nil { fmt.Println("recovered:", r) } } func a() { defer handle(); panic("A") } // 1 func b() { defer func() { handle() }();…
func main() { defer func() { if r := recover(); r != nil { fmt.Println("recovered", r) } }() var wg sync.WaitGroup wg.Add(1) go func() { defer wg.Done() var m…
func main() { defer func() { fmt.Println("recovered:", recover()) }() defer func() { fmt.Println("cleanup") panic("second") }() defer fmt.Println("first defer")…
var x int8 = 127 x++ fmt.Println(x) // ? var u uint8 = 0 u-- fmt.Println(u) // ? m := int8(-128) fmt.Println(-m) // ? fmt.Println(-7/2, -7%2) // ? // const big = 1 << 62…
fmt.Println(0.1+0.2 == 0.3) // true a, b := 0.1, 0.2 fmt.Println(a+b == 0.3) // false fmt.Println(a + b) // 0.30000000000000004 const huge = 1e1000 // fine as an untyped…
s := "héllo" fmt.Println(len(s)) // 6 fmt.Println(s[1]) // 195 fmt.Printf("%c %q\n", s[1], s[1:3]) // Ã "é" for i, r := range s { fmt.Print(i, ":", string(r), " ") //…
var a, b any = []int{1}, []int{1} fmt.Println(a == b) // panic: runtime error: comparing uncomparable type []int seen := map[any]bool{} seen[[]int{1}] = true // panic:…
var ErrNotFound = errors.New("not found") e1 := fmt.Errorf("get user: %v", ErrNotFound) e2 := fmt.Errorf("get user: %w", ErrNotFound) fmt.Println(e1) // get user: not…
func Count(n int) iter.Seq[int] { return func(yield func(int) bool) { for i := range n { yield(i) // BUG: ignores the return value } } } func main() { for x := range…
func main() { var n int var wg sync.WaitGroup for range 1000 { wg.Add(1) go func() { defer wg.Done() n++ // data race }() } wg.Wait() fmt.Println(n) // usually < 1000,…
s := []int{1, 2, 3, 4, 5} t := append(s[:1], s[3:]...) fmt.Println(t, s) u := []int{1, 2, 3, 4, 5} v := slices.Delete(u, 1, 3) fmt.Println(v, u) Output: [1 4 5] [1 4 5 4…
type Base struct{} func (Base) Name() string { return "base" } func (b Base) Greet() string { return "hi " + b.Name() } type Derived struct{ Base } func (Derived) Name()…
func describe(x any) string { switch v := x.(type) { case nil: return "nil" case int, int64: // return fmt.Sprint(v + 1) // compile error: v is any here return…
package main import "fmt" var ( a = c + b b = f("b") c = f("c") d = f("d") ) func f(s string) int { fmt.Print(s, " ") return len(s) } func init() { fmt.Print("init1 ") }…