Go (Golang) MCQ

Explanation

Go was designed by Robert Griesemer, Rob Pike, and Ken Thompson at Google and released in 2009.

Explanation

Go source files use the .go extension.

Explanation

The short variable declaration x := 5 infers the type. var x int = 5 is the explicit form. := cannot be used at package level.

Explanation

In Go, every type has a zero value. int/float = 0, bool = false, string = "", pointer/slice/map/channel/function = nil.

Explanation

go f() launches f as a goroutine. Goroutines are multiplexed onto OS threads by the Go scheduler and are extremely cheap (2-8KB initial stack).

Explanation

ch := make(chan int) creates an unbuffered channel. Send with ch <- val and receive with val := <-ch. Channels synchronize goroutines.

Explanation

defer f.Close() ensures f.Close() is called when the function exits. Deferred calls run in LIFO order.

Explanation

A slice ([]T) has a pointer, length, and capacity. make([]int, 5) or []int{1,2,3}. append() grows it automatically.

Explanation

map[string]int{"a": 1} is a map literal. make(map[string]int) initializes an empty map. Access with m["key"]; delete with delete(m, "key").

Explanation

type Writer interface { Write([]byte) (int, error) } — any type with a Write method satisfies Writer without explicit declaration.

Explanation

_, err := f() discards the first return value. The blank identifier prevents "declared and not used" compile errors.

Explanation

func divide(a, b float64) (float64, error) returns both a result and an error, avoiding exceptions.

Explanation

result, err := doSomething(); if err != nil { return err } is the idiomatic Go error handling pattern.

Explanation

interface{} (aliased as any in Go 1.18) can hold any value. Use type assertions or type switches to retrieve the underlying value.

Explanation

type Point struct { X, Y int } defines a struct. Structs are value types in Go; assignment copies the entire struct.

Explanation

func (p Point) String() string { ... } or func (p *Point) Scale(n int) { p.X *= n } define methods. Pointer receivers allow mutation.

Explanation

Use *T receivers to modify the struct or avoid copying. Use T receivers when you only need read access and the struct is small.

Explanation

make([]int, 5, 10) creates a slice with length 5, capacity 10. make(map[string]int) initializes a map. make(chan int, 10) creates a buffered channel.

Explanation

p := new(int) allocates an int zeroed to 0 and returns *int. For structs, prefer &MyStruct{} which can also initialize fields.

Explanation

Only programs (not libraries) use package main with a func main(). Libraries use any other package name.

Explanation

go.mod defines the module (module example.com/myapp) and lists direct dependencies with versions.

Explanation

select { case v := <-ch1: ... case ch2 <- x: ... default: ... } allows non-blocking or multiplexed channel operations.

Explanation

panic(msg) stops normal execution and begins unwinding. Use recover() inside a deferred function to catch panics. Don't use panic for ordinary errors.

Explanation

recover() is only useful inside a deferred function. It stops the panic and returns the panic value, allowing the program to continue.

Explanation

type Animal struct { ... }; type Dog struct { Animal; Name string } embeds Animal. Dog has all Animal methods directly.

Explanation

for i, v := range slice { } iterates with index and value. for k, v := range myMap { } iterates map keys and values.

Explanation

func sum(nums ...int) int accepts any number of ints. Inside, nums is []int. Call as sum(1,2,3) or sum(slice...).

Explanation

init() is called automatically after all variable declarations in the package. A package can have multiple init() functions.

Explanation

val, ok := i.(string) safely checks if i holds a string. Without ok, a failed assertion panics.

Explanation

switch v := i.(type) { case int: ... case string: ... } matches the runtime type of i.

Explanation

Go uses capitalization for visibility. Println, Error, and UserID are exported. println, myVar are unexported (package-private).

Explanation

const Pi = 3.14159 or const ( A = iota; B; C ) using iota for enum-like values.

Explanation

const ( A = iota; B; C ) assigns A=0, B=1, C=2. iota resets to 0 in each const block.

Explanation

for v := range ch { } reads from ch until close(ch) is called. Without close, the loop blocks forever.

Explanation

The two-value map access val, ok := m[key] sets ok to false (and val to zero value) if key is absent.

Explanation

Go has no class inheritance. Functionality is composed by embedding structs and satisfying interfaces, which encourages smaller, focused types.

Explanation

s = append(s, 1, 2, 3) returns a potentially new slice (if reallocation occurred). Always use the return value.

Explanation

wg.Add(1); go func() { defer wg.Done(); }(); wg.Wait() blocks until all added goroutines call Done.

Explanation

A rune is an alias for int32, holding a single Unicode code point. for _, r := range "Go" iterates runes, not bytes.

Explanation

context.WithCancel, WithDeadline, WithTimeout create contexts. Pass ctx as the first argument to functions to propagate cancellation.

Explanation

Go's runtime scheduler (GOMAXPROCS=CPU cores by default) uses M:N threading: M goroutines on N OS threads, with work-stealing across P (processor) queues.

Explanation

make(chan int) is unbuffered — send blocks until received. make(chan int, 5) buffers up to 5 values; send only blocks when buffer is full.

Explanation

errors.Is(err, ErrNotFound) unwraps the error chain to check if any error matches ErrNotFound. Use errors.As() to extract a specific error type.

Explanation

mu.Lock(); /* critical section */ mu.Unlock() prevents concurrent goroutines from accessing shared state simultaneously. Use defer mu.Unlock() for safety.

Explanation

RLock()/RUnlock() for read-only access; Lock()/Unlock() for writes. Many goroutines can RLock simultaneously; Lock waits for all readers to finish.

Explanation

fmt.Errorf("parsing: %w", err) wraps err. errors.Is(wrappedErr, io.EOF) traverses the chain.

Explanation

var once sync.Once; once.Do(func() { /* init */ }) runs the function at most once, safely from any number of goroutines.

Explanation

sync.Pool stores temporary objects. Get() retrieves a pooled object; Put() returns it. The GC may collect pooled objects at any time.

Explanation

Go's GC targets <1ms STW pauses. It marks objects concurrently with the program. The write barrier maintains invariants during concurrent marking.

Explanation

var s []int is nil (s == nil is true). s := []int{} or make([]int, 0) is empty (s == nil is false). Both have length 0 and can be appended to.

Explanation

runtime.GOMAXPROCS(n) sets the number of P (processors) in the scheduler. Default is runtime.NumCPU(), enabling true parallelism.

Explanation

adder := func(x int) func() int { sum := 0; return func() int { sum += x; return sum } }(5) — the inner func closes over sum.

Explanation

b := a copies the slice header — both share the same backing array. copy(b, a) copies element values; b must be pre-allocated.

Explanation

Goroutine leaks occur when goroutines wait for channels that are never signaled. Use context cancellation or timeout to ensure goroutines can exit.

Explanation

go vet catches bugs that the compiler misses, such as wrong printf format verbs or copying a mutex by value.

Explanation

ctx, cancel := context.WithCancel(parent) — calling cancel() propagates cancellation to all contexts derived from ctx.

Explanation

If a variable's address is taken and stored in a longer-lived location, it escapes to the heap. Stack allocation is cheaper (no GC pressure).

Explanation

atomic.AddInt64(&counter, 1) increments counter atomically without a mutex, using CPU compare-and-swap instructions.

Explanation

Go uses segmented/contiguous stacks that start small and grow automatically. This makes creating thousands of goroutines practical.

Explanation

type error interface { Error() string } — any type implementing Error() string satisfies the error interface. Create with errors.New() or fmt.Errorf().

Explanation

Sentinel errors allow callers to check err == io.EOF. With error wrapping, use errors.Is(err, io.EOF) to check the chain.

Explanation

ctx, cancel := context.WithTimeout(parent, 5*time.Second) is equivalent to context.WithDeadline(parent, time.Now().Add(5*time.Second)).

Explanation

The race detector instruments memory accesses. When two goroutines access the same memory without synchronization, it reports "DATA RACE" with a full stack trace.

Explanation

GOPROXY controls where go get fetches modules. The default proxy.golang.org caches all public modules. GONOSUMDB and GOPRIVATE control private module access.

Explanation

If Stringer is implemented with *T receiver, only *T satisfies Stringer, not T. You cannot take the address of an interface value to recover the original pointer.

Explanation

//go:generate go run golang.org/x/tools/cmd/stringer -type=Status in source triggers stringer when running go generate. The developer must manually run go generate.

Explanation

//go:build linux && amd64 includes the file only when compiling for Linux on x86-64. Custom tags: //go:build integration with go test -tags integration.

Explanation

io.Copy(dst io.Writer, src io.Reader) works with files, buffers, network connections, and custom types — all implementing these two methods.

Explanation

func NewServer(opts ...Option) — Option is func(*Server). WithTimeout(d) returns func(*Server) { s.timeout = d }. Popular in Go libraries like grpc-go.

Explanation

fmt.Printf("%d", "hello") is caught by go vet as a vet error. It also catches unreachable code, suspicious type assertions, and mutex copies.

Explanation

Unbuffered: send blocks until received. Buffered with 1: send succeeds immediately if buffer empty; blocks only when full. Used for signaling without blocking.

Explanation

tests := []struct{in string; want int}{{"abc",3},{"",0}}; for _, tt := range tests { t.Run(tt.in, func(t *testing.T) { ... }) }

Explanation

http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { }) converts a function to an http.Handler by implementing ServeHTTP.

Explanation

time.NewTimer(5*time.Second) fires once. time.NewTicker(1*time.Second) fires every second. Always call Stop() to release resources.

Explanation

net/http automatically spawns a goroutine per connection. Handlers are called concurrently — protect shared data with mutexes or channels.

Explanation

//go:generate stringer -type=Weekday generates func (w Weekday) String() string returning "Monday", "Tuesday", etc. Avoids hand-writing fmt.Stringer.

Explanation

g, ctx := errgroup.WithContext(parent); g.Go(func() error { return work(ctx) }); if err := g.Wait(); err != nil { } — first error cancels ctx.

Explanation

For structs, &Point{X: 1, Y: 2} is idiomatic and allows initialization. new(Point) gives a zeroed *Point. For non-struct types (maps, slices), use make instead.

Explanation

go.work (Go 1.18+) lists module paths: use ./module1 use ./module2. go build and go test in any module use local versions of listed modules.

Explanation

Use log.Fatal in main() for unrecoverable startup errors. panic is for invariant violations. os.Exit skips deferred cleanup — prefer panic in libraries.

Explanation

go test -race or go run -race instruments the binary. The race detector catches actual concurrent reads/writes, not just potential ones.

Explanation

The Go memory model (2022 revision) specifies that a send on a channel happens before the corresponding receive, and close happens before a receive of the zero value.

Explanation

Import net/http/pprof for HTTP endpoints. Use go tool pprof to analyze CPU profiles (find hot paths), heap profiles (memory leaks), and goroutine dumps.

Explanation

func Min[T constraints.Ordered](a, b T) T uses a type parameter T constrained to Ordered. The compiler generates specialized code or uses GC shape stenciling.

Explanation

Go 1.18 shares instantiations for types with the same underlying GC shape (e.g., all pointers share one instantiation). This differs from C++'s full specialization per type.

Explanation

sync.Map uses two maps internally: a read-optimized atomic map and a dirty write map. It excels at stable-keyed high-concurrency reads. mutex+map is often better for write-heavy workloads.

Explanation

unsafe.Pointer, unsafe.Sizeof, unsafe.Offsetof are used for performance-critical code and C interop (cgo). Breaks type safety — use sparingly.

Explanation

Go's linker performs dead code elimination. Only reachable code from main (and init) is included. This is why Go binaries are self-contained and relatively small.

Explanation

reflect.TypeOf(x), reflect.ValueOf(x) enable inspecting types and values. Used by encoding/json, ORM libraries, and test frameworks. Avoid reflection in hot paths.

Explanation

cgo enables calling C libraries. Each cgo call must switch from a goroutine stack to an OS thread stack. This adds ~200ns overhead per call and disables cross-compilation.

Explanation

myproject/internal/auth can only be imported by packages within myproject/. External packages get a compile-time error, enforcing package privacy without module boundaries.

Explanation

Before Go 1.17, all arguments and return values were passed on the stack. The new register ABI passes integer args in RAX, RBX, RCX, RDI, RSI, R8, R9, R10, R11.

Explanation

sync.Map benchmarks show benefits for stable, high-concurrency read-heavy maps. For general use, measure: sync.Map has higher overhead per operation due to interface{} boxing.

Explanation

go build -gcflags=-m shows inlining decisions. Functions exceeding the budget are not inlined. go:noinline and go:yesplease override. Inlining enables further optimizations.

Explanation

go test caches results based on code and test flags. go test -count=1 bypasses this cache, crucial for benchmarks or tests with external state.

Explanation

The Go linker starts from main and marks reachable symbols. Unreachable functions and their dependencies are excluded. This is why Go binaries include no unused code.

Explanation

func FuzzReverse(f *testing.F) { f.Fuzz(func(t *testing.T, s string) { ... }) } — the fuzzer mutates s to find edge cases. Failing inputs are saved to testdata/fuzz/.

Explanation

go build -gcflags="-m -m" shows detailed escape analysis. "moved to heap" means an allocation occurs. Closures over pointers, interface conversions often cause escape.

Explanation

An interface value is two words: *type and *data. For small scalars, data is stored directly. For pointers and larger types, it points to heap. Avoid interfaces in hot paths.

Explanation

runtime.StartCPUProfile writes to a file. net/http/pprof exposes /debug/pprof/ endpoints. go tool pprof http://localhost:8080/debug/pprof/heap provides interactive analysis.