Golang quiz — 75 questions with answers and explanations

Answer: C

Prints 3 then -3. Division between two ints is integer division; Go truncates the fractional part TOWARD ZERO (truncate toward zero), so 7/2 = 3 and -7/2 = -3 — unlike Python, which rounds down (-4). To get a float result, at least one operand must be a float. (FREE)

Answer: B

In Go, a type satisfies an interface implicitly: it just needs to define all the methods the interface requires, with no implements keyword or link declaration. The compiler checks this at compile time. This lets interfaces be defined on the consumer side, decoupled from the concrete type.

Answer: B

Go treats errors as values: a function returns error in the last position and the caller checks if err != nil. Use error for all expected failures (I/O, parse, validate). Only panic on a bug or a broken invariant you can't continue from; put recover in a defer to stop the panic at a boundary and avoid crashing the whole process.

Answer: A

An array [N]T has its length N as part of the type and is copied by value on assignment or when passed to a function. A slice is a lightweight struct with a pointer to a backing array, len, and cap; it's a dynamic reference "window" that grows via append and shares data with other slices over the same backing array. In practice Go uses slices almost everywhere.

Answer: B

Every Go variable declared without initialization gets the zero value of its type: s = "", n = 0, p = nil. General rule: numbers → 0, string → empty string, bool → false, pointer/slice/map/channel/interface → nil, struct → the zero value of each field. There's no undefined or garbage value like in C.

Answer: A

x := 10 (short declaration) both declares and assigns, the type is inferred from the right-hand side, and it can ONLY be used inside a function. var x = 10 does the same but also works at package level. Inside a function, := is the most common form; var is used when declaring at package level or when you want the variable to get its zero value (var x int).

Answer: C

The first letter of the name decides: uppercase is exported — other packages can import and use it (fmt.Println, http.Get); lowercase is unexported — only usable within the package. Go has no public/private keyword. The rule applies to every identifier: functions, variables, constants, types, and each field in a struct.

Answer: B

It prints [1 2 3]. range copies the VALUE of each element into the loop variable v — modifying v modifies the copy, so the original slice is unchanged. To change the actual elements, assign through the index: for i := range nums { nums[i] *= 10 }. This rule also applies to structs in a slice: modifying a field of v has no effect either.

Answer: C

Prints 0 false. Looking up a missing key on a map doesn't panic: the comma-ok form v, ok := m["b"] returns the zero value of the value type (int → 0) and ok == false. If you drop ok, you only get 0 — you can't tell a missing key from a key whose value is 0. (FREE)

Answer: B

The correct pattern: wg.Add(1) BEFORE the go statement, defer wg.Done() inside the goroutine, and wg.Wait() on the waiting side. Calling Add inside the goroutine is a classic race — Wait can see a counter of 0 and return before the goroutine even runs. Done beyond Add panics with a negative counter.

Answer: D

int32. A rune represents one Unicode code point, which needs up to 21 bits, so it must use a 32-bit type. Meanwhile byte is an alias for uint8. These two types exist to make intent clear when working with strings.

Answer: A

len is the number of elements the slice currently holds. cap is the number of elements the underlying array can hold starting from the slice's start position. When append exceeds capacity, the runtime allocates a new, larger array and copies the data over — at that point the old and new slices no longer share an underlying array.

Answer: D

It is an interface that declares no methods. Since every type satisfies that empty condition, a variable of this type can hold any value. In return, you can't call any method on it until you pin down the concrete type via a type assertion or type switch.

Answer: D

The operation may already have failed while the program keeps running as if nothing happened. The other return values are then usually zero or incomplete, so later code processes bad data and the real error surfaces elsewhere, far from the cause.

Answer: D

go.mod declares the module and its dependencies with their versions. go.sum stores the cryptographic hash of each downloaded version, to verify the contents haven't been altered. Both must be committed to the repository.

Answer: B

errors.New creates an error from a fixed string. fmt.Errorf takes a format string, so it can interpolate values into the message and, more importantly, supports the %w verb to wrap another error — preserving the original for later errors.Is and errors.As checks.

Answer: C

Two conditions together: the package must be named main, and it must have a func main() that takes no parameters and returns nothing. Missing either one means the build command only produces a library, not an executable.

Answer: D

In reverse declaration order — the last declared runs first. Deferred calls are pushed onto a stack, and this order matches releasing resources in the opposite order from opening them.

Answer: C

It does not fall through to the next case, so no break statement is needed at the end of each case. Falling through must be declared explicitly — this design eliminates the whole class of forgotten-break bugs.

Answer: A

Reading returns the type's zero value, writing panics. An uninitialized map has the nil value, and the language allows reading from it like an empty map, but there is nowhere to write into it.

Answer: D

Prints 2 1 0. defer runs LIFO; the argument i is evaluated IMMEDIATELY when the defer is reached, so the three calls capture 0, 1, 2 and print in reverse when main returns. (FREE)

Answer: C

Panic: assignment to entry in nil map. var m map[string]int only creates a nil map; reading a nil map safely returns the zero value, but WRITING panics. You must make(map[string]int) or use a literal before assigning. (FREE)

Answer: C

Prints 0 1 2 4. iota starts at 0 and increments by 1 on each line of the const block, including the _ line. Lines B, C, E implicitly inherit the = iota expression. The _ line "swallows" the value 3, so E = 4. (FREE)

Answer: C

Prints 6 5. A string in Go is a UTF-8 byte sequence; len(s) counts BYTES. The character "é" takes 2 bytes, so the string is 6 bytes long but only 5 runes (characters). To count characters, use utf8.RuneCountInString or range. (FREE)

Answer: C

Prints true. A struct whose fields are all comparable (here all int) can be compared with ==, matching field by field by value. a and b are both {1, 2} so they're equal — no need for reflect.DeepEqual in this case. (FREE)

Answer: A

A goroutine is a lightweight thread managed by the Go runtime, not an OS thread. Go's M:N scheduler multiplexes many goroutines onto a small number of OS threads. A goroutine stack starts at only about 2KB and grows and shrinks automatically, while an OS thread costs hundreds of KB up to a few MB, so creating thousands of goroutines is normal.

Answer: D

An unbuffered channel (make(chan T)) is synchronous: each send blocks until a receiver is there, creating a handshake point between the two goroutines. A buffered channel (make(chan T, n)) has capacity n: a send blocks only when the buffer is full, a receive blocks only when the buffer is empty, which decouples the pace of producer and consumer.

Answer: C

select lets a goroutine wait on multiple channel operations at once and run one case that is ready. If several cases are ready at the same time, Go picks randomly to avoid starvation. With default, select is non-blocking. It's the core tool for timeouts, cancellation and fan-in/fan-out.

Answer: A

context.Context carries cancellation signals, deadlines/timeouts, and a small amount of request-scoped values across a call chain and goroutines. A function that takes ctx listens on ctx.Done() to stop early when the request is cancelled or times out. Convention: pass ctx as the first parameter, don't store it in a struct, and don't use it as a parameter bag.

Answer: D

sync.WaitGroup synchronizes on a completion point: Add(n) before starting, each goroutine does defer wg.Done(), and wg.Wait() blocks until the counter hits 0 — used to wait for a whole group of goroutines to finish. sync.Mutex is a mutual-exclusion lock: Lock/Unlock wrap a critical section so only one goroutine touches shared state at a time. Different purposes, often used together.

Answer: B

Prints 1 2. A channel with buffer 2 lets you send two values without a ready receiver — sends only block when the buffer is FULL. The buffer is a FIFO queue, so receives come back in send order. If you change it to make(chan int) (unbuffered), the line ch <- 1 blocks forever in the single goroutine → deadlock. (FREE)

Answer: B

Prints 2 [1 2]. copy(dst, src) copies min(len(dst), len(src)) elements and returns the number copied — here min(2, 3) = 2. copy does NOT grow dst; the classic trap is dst := make([]int, 0, n) (len 0), which makes copy copy 0 elements even though cap has room. (FREE)

Answer: A

An interface value is a (type, value) pair and is only nil when BOTH are nil. return e where e is a nil *MyErr creates the interface (type=*MyErr, value=nil) — the type isn't nil, so err != nil is true. This is the "typed nil" trap. To avoid it: a function returning error should return nil explicitly, not return a nil error pointer variable.

Answer: B

Since Go strings are immutable, s += x allocates a new string and copies all the old content each time. Concatenating n times has quadratic cost. strings.Builder writes into a byte buffer that grows exponentially and returns the string once, so the total cost is linear.

Answer: C

The two-value form is safe: if the type doesn't match, v gets the zero value and ok is false, and the program continues. The one-value form panics immediately when the type doesn't match. In production code you almost always use the two-value form.

Answer: D

It generates a sequence of increasing integers: it takes the value 0 on the first line of the const block and increments by one on each subsequent line. This is how Go declares enums without manual numbering, so inserting a value in the middle doesn't require changing the lines after it.

Answer: C

make a new slice of the right length, then call copy. Both assignment and slicing only copy the descriptor (pointer, length, capacity), not the data, so the two slices still share the same underlying array and a change to one is visible in the other.

Answer: D

The program can stop with a fatal error reporting concurrent map access, e.g. concurrent map read and map write or concurrent map writes. This is intentional runtime behavior in many cases, but you shouldn't rely on it as a protection mechanism; maps generally still need synchronization when goroutines write to them.

Answer: A

Random, and two consecutive iterations can produce different orders. Go deliberately randomizes the starting point rather than merely not guaranteeing an order — the goal is to immediately expose code that accidentally depends on iteration order.

Answer: D

The embedded struct's fields and methods are promoted to the outer struct, so you access them directly as outer.Field instead of outer.Inner.Field. This is composition, not inheritance: there is no polymorphism, and a same-named method on the outer struct only shadows rather than overrides.

Answer: B

No. The method set of T includes only methods with value receivers. The method set of *T includes both. So only *T satisfies that interface, and assigning a T value to an interface variable is a compile error.

Answer: D

errors.Is(err, target) asks whether anything in the error chain equals target exactly — used with sentinel errors. errors.As(err, &target) finds the first error matching a type and assigns it to the variable, so you can read that error type's own fields.

Answer: B

Receiving returns immediately with the zero value of the element type, without blocking — and keeps doing so forever. Use the two-value form v, ok := <-ch to distinguish: ok being false means the channel is closed and drained.

Answer: B

The passed function runs exactly once over the whole program lifetime, no matter how many goroutines call it. More importantly, later callers wait until that first run completes, so nobody observes a half-initialized state.

Answer: C

Start N goroutines that all range over a shared jobs channel. Each value sent to the channel is received by exactly one goroutine, so distribution is automatic and self-balancing — whichever worker is idle picks up the next job.

Answer: B

To release resources. The child context is registered with its parent and a timer is created; if the work finishes early without calling cancel, both linger until the timeout expires. For a function called many times, that is a real leak.

Answer: A

The maximum number of OS threads allowed to execute Go code simultaneously — that is, the real level of parallelism. It does not limit the number of goroutines, which can go up to millions. Since Go 1.5, the default value equals the number of CPU cores the runtime sees.

Answer: D

The heap growth ratio that triggers the next collection cycle. The default is 100, meaning it runs again when the heap reaches twice the live size from the previous collection. Setting it higher means less frequent collection but more RAM usage; setting it lower is the opposite.

Answer: A

All cases share the same checking logic, so adding a new case is just adding a line of data. Combined with t.Run so each case becomes a named subtest, the report points out exactly which case failed and the remaining cases still run.

Answer: D

The benchmark runner decides this value itself: it starts with a small number of iterations, measures, then increases until the total time is long enough (about one second by default) for a stable result. The reported result is the average time per iteration.

Answer: A

None. http.DefaultClient leaves the timeout field at its zero value, meaning it waits forever. If the target server stops responding without closing the connection, the calling goroutine hangs indefinitely — and in a service, this accumulates into resource exhaustion.

Answer: A

To return the TCP connection to the pool for reuse. If you don't close it, the connection is held forever, and after enough requests the process runs out of file descriptors. Call it right after checking the error, before reading the body.

Answer: B

Call Stop() when you no longer need ticks, usually with a defer right after creating it if the ticker's lifetime matches the current scope. Since Go 1.23, the GC can reclaim an unreferenced ticker even without Stop(), but Stop() is still the correct way to stop one explicitly.

Answer: A

Go 1.18. They let you write a single function or type shared across many data types while still being checked at compile time. Before that you had only two options: duplicate the code for each type, or use interface{} with type assertions and lose type safety.

Answer: A

The whole program crashes. The panic unwinds the goroutine's stack and, if it reaches the top without being recovered, the runtime terminates the entire process. Go does not isolate errors per goroutine.

Answer: A

It collects errors from the goroutines. Wait() returns the first error encountered instead of nothing, and the version built with errgroup.WithContext cancels the shared context as soon as the first goroutine fails — so remaining goroutines can stop early if they respect the context.

Answer: B

No. It terminates the process immediately, skipping all pending defers. The consequence is unclosed files, unflushed buffers, and any other cleanup steps never running.

Answer: C

It creates a new variable that shadows the outer one within that block. Assignments inside affect the new variable, while the outer variable keeps its old value after the block ends. This is the source of bugs that look like assignments do nothing.

Answer: B

Parameters should be declared as interface types so callers can pass any implementation — easy to swap in tests. Return values should be concrete types so callers get the full method set and decide for themselves whether they need abstraction.

Answer: B

Append the version suffix to the end of the path: example.com/lib/v2. Because the paths differ, Go treats the two major versions as completely separate modules — which lets a single build contain both v1 and v2 when dependencies require different ones.

Answer: D

gofmt normalizes formatting — indentation, whitespace, import order — and doesn't care about semantics. go vet does semantic analysis to find patterns that compile but are almost certainly bugs, for example a format string that doesn't match its arguments.

Answer: D

Yes. Slicing does not copy the data but creates a new view onto the same underlying array, so writing through this slice is visible to the other. To make them independent you must copy explicitly.

Answer: C

The entire 100MB underlying array is not freed. The sub-slice still references it, so the GC cannot reclaim the rest even though the program only uses the first ten bytes.

Answer: A

Each loop iteration creates a new timer, and a timer is only reclaimed after it fires. With a fast loop and a long wait, the number of pending timers in memory accumulates very quickly.

Answer: A

The read and write timeout settings. By default there are no limits, so a slow or deliberately connection-holding client can occupy resources indefinitely — and this is a real attack.

Answer: C

The field name is lowercase and therefore not exported. The encoding package uses reflection and can only access exported fields, so it skips it entirely — no error is returned.

Answer: D

When reads vastly outnumber writes. Many concurrent readers can proceed in parallel, so throughput increases. If the write ratio is high, the benefit does not offset the extra management cost of this lock type.

Answer: D

The sender, because only it knows when the data is done. Sending on a closed channel causes a panic, so letting the receiver close it invites an unexpected program stop.

Answer: B

Every file stays open until the function returns, because a deferred call is tied to the function, not the loop. With ten thousand files, the program runs out of file descriptors before the function ends.

Answer: D

After package-level variables are initialized and before main runs. Each package runs exactly once, in dependency order: imported packages finish initializing before the current one starts.

Answer: B

It compares every field by value, but this is only valid when all fields are comparable. A struct containing a slice, map or function is rejected at compile time, not at runtime.

Answer: B

The separator-based split produces empty elements when two spaces appear in a row, while the other one groups all whitespace together and drops the extras. For user-supplied text, the second is almost always what you want.

Answer: D

Only data scoped to a request, such as a trace ID, the caller's identity or locale info. Do not use it for required arguments or dependencies — those belong in the function signature or in initialization-time injection.

Answer: A

It hit a line longer than the default buffer limit. The scan loop stops as if the file had ended, and the error only surfaces when you check the error function after the loop — a step that is very often skipped.

Answer: C

The result was cached because the source and its input factors were unchanged. To force a rerun, add the flag that sets the count to one, or clear the build cache.