Top Golang Interview Questions: Coding Patterns & Solutions

package main

import (
	"fmt"
	"sync"
)

func producer(nums ...int) <-chan int {
	out := make(chan int)
	go func() {
		for _, n := range nums {
			out <- n
		}
		close(out)
	}()
	return out
}

func worker(id int, in <-chan int) <-chan int {
	out := make(chan int)
	go func() {
		for n := range in {
			result := n * n // simulate work
			fmt.Printf("Worker %d processed %d\n", id, n)
			out <- result
		}
		close(out)
	}()
	return out
}

func fanIn(channels ...<-chan int) <-chan int {
	out := make(chan int)
	var wg sync.WaitGroup
	for _, ch := range channels {
		wg.Add(1)
		go func(c <-chan int) {
			defer wg.Done()
			for v := range c {
				out <- v
			}
		}(ch)
	}
	go func() {
		wg.Wait()
		close(out)
	}()
	return out
}

func main() {
	in := producer(1, 2, 3, 4, 5)
	c1 := worker(1, in)
	c2 := worker(2, in)
	c3 := worker(3, in)
	for result := range fanIn(c1, c2, c3) {
		fmt.Println("Result:", result)
	}
}

package main

import (
	"fmt"
	"time"
)

func main() {
	ch := make(chan string)

	go func() {
		time.Sleep(2 * time.Second)
		ch <- "result"
	}()

	select {
	case res := <-ch:
		fmt.Println(res)
	case <-time.After(1 * time.Second):
		fmt.Println("timeout")
	}

	// Non-blocking send
	select {
	case ch <- "msg":
		fmt.Println("sent")
	default:
		fmt.Println("not sent")
	}

	// Non-blocking receive
	select {
	case msg := <-ch:
		fmt.Println("received", msg)
	default:
		fmt.Println("no message")
	}
}

package main

import (
	"errors"
	"fmt"
	"os"
)

var ErrNotFound = errors.New("item not found")

func getItem(id int) (string, error) {
	if id == 0 {
		return "", ErrNotFound
	}
	return "item", nil
}

func processItem(id int) error {
	item, err := getItem(id)
	if err != nil {
		return fmt.Errorf("processItem: %w", err)
	}
	fmt.Println("Processing", item)
	return nil
}

func main() {
	err := processItem(0)
	if errors.Is(err, ErrNotFound) {
		fmt.Println("Error is ErrNotFound")
	}
	fmt.Println(err)

	// Unwrap
	fmt.Println(errors.Unwrap(err))
}

package main

import "fmt"

type Shape interface {
	Area() float64
}

type Circle struct {
	Radius float64
}

func (c Circle) Area() float64 {
	return 3.14 * c.Radius * c.Radius
}

type Rectangle struct {
	Width, Height float64
}

func (r Rectangle) Area() float64 {
	return r.Width * r.Height
}

func printArea(s Shape) {
	fmt.Printf("Area: %0.2f\n", s.Area())
}

func main() {
	c := Circle{Radius: 5}
	r := Rectangle{Width: 3, Height: 4}
	printArea(c)
	printArea(r)

	// Type assertion
	var s Shape = Circle{Radius: 7}
	circle, ok := s.(Circle)
	if ok {
		fmt.Println("It's a circle with radius", circle.Radius)
	}

	// Type switch
	switch v := s.(type) {
	case Circle:
		fmt.Println("Circle radius:", v.Radius)
	case Rectangle:
		fmt.Println("Rectangle dimensions:", v.Width, v.Height)
	default:
		fmt.Println("Unknown shape")
	}
}

package main

import "fmt"

func main() {
	arr := [5]int{1, 2, 3, 4, 5}
	s := arr[1:4] // length 3, capacity 4
	fmt.Println("slice:", s, "len:", len(s), "cap:", cap(s))

	s2 := s[:cap(s)] // extend to full capacity
	fmt.Println("s2:", s2)

	// Modifying s2 affects original array
	s2[0] = 99
	fmt.Println("arr:", arr)

	// Append beyond capacity allocates new array
	s3 := append(s, 6, 7, 8, 9)
	fmt.Println("s3:", s3, "cap:", cap(s3))
	fmt.Println("arr unchanged:", arr)
}

package main

import "fmt"

type Base struct {
	ID int
}

func (b Base) Print() {
	fmt.Println("Base ID:", b.ID)
}

type Derived struct {
	Base
	Name string
}

func (d Derived) Print() {
	fmt.Println("Derived Name:", d.Name, "ID:", d.ID)
}

func main() {
	d := Derived{Base: Base{ID: 1}, Name: "example"}
	d.Print()          // calls Derived.Print
	d.Base.Print()     // calls Base.Print explicitly
	fmt.Println(d.ID)  // promoted field
}

package main

import (
	"context"
	"fmt"
	"time"
)

func longRunningTask(ctx context.Context) error {
	select {
	case <-time.After(5 * time.Second):
		fmt.Println("Task completed")
		return nil
	case <-ctx.Done():
		fmt.Println("Task cancelled:", ctx.Err())
		return ctx.Err()
	}
}

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
	defer cancel()

	err := longRunningTask(ctx)
	if err != nil {
		fmt.Println("Error:", err)
	}
}

package main

import (
	"fmt"
	"sync"
)

type Object struct {
	Data []byte
}

var pool = sync.Pool{
	New: func() interface{} {
		return &Object{Data: make([]byte, 1024)}
	},
}

func main() {
	obj := pool.Get().(*Object)
	// Use obj
	fmt.Println("Got object with data len:", len(obj.Data))
	// Reset before putting back
	obj.Data = obj.Data[:0]
	pool.Put(obj)

	// Next get reuses the same object
	obj2 := pool.Get().(*Object)
	fmt.Println("Got object again:", len(obj2.Data))
}