What is the difference between make and new in Go?

new(T) allocates zeroed storage and returns a pointer *T, working for any type. make(T) initializes the internal structure of slices, maps, and channels only, and returns the value T itself, not a pointer. Use make for those three reference types and new for everything else.

Does append always modify the original slice?

Not necessarily. append reuses the backing array if there is spare capacity, otherwise it allocates a new larger array and copies. Because the result may point to new storage, you must always assign the return value back, as in s = append(s, x).

When does close panic?

close panics if the channel is nil, already closed, or receive-only. Sending to a closed channel also panics. Closing is meant to signal no more values will be sent, so only the sender should close a channel.

What does recover do outside a deferred function?

recover only stops a panic when called directly inside a deferred function. Called anywhere else it returns nil and has no effect. The deferred function must be on the goroutine that is panicking to catch it.

Are min, max, and clear available in older Go?

No. The built-ins min and max were added in Go 1.21 and clear was also added in Go 1.21. On earlier toolchains they are not pre-declared and you must write equivalent helpers yourself.

Go Built-in Functions Reference

Go keeps its language small by providing a fixed set of pre-declared built-in functions that live in no package and cannot be imported or shadowed sensibly. They handle allocation, slicing, maps, channels, and panics. This tool is a searchable reference covering each built-in’s signature, the types it accepts, and exactly when it panics.

How it works

Built-ins are part of the language spec, not the standard library, so they need no import. Several are generic over many types (len, cap, append), while others are restricted to specific reference types (make, close, delete). The reference groups them by purpose:

Allocation — make (slices/maps/channels), new (any type, returns a pointer).
Slices — len, cap, append, copy, clear.
Maps — len, delete, clear.
Channels — make, len, cap, close.
Ordered values — min, max (Go 1.21+).
Errors/flow — panic, recover.
Complex numbers — complex, real, imag.

Worked example

s := make([]int, 0, 4) // len 0, cap 4
s = append(s, 1, 2, 3) // assign back: append may reallocate
n := copy(dst, s)      // n = number of elements copied (min of lengths)
delete(m, "key")       // no-op if key absent, never panics
close(ch)              // panics if ch is nil or already closed

The key habit is reassigning the result of append, because it may return a slice backed by a freshly allocated array.

Notes

len and cap are the only built-ins whose results can be constant when the argument is an array or array pointer with no side effects.
delete on a missing key is a safe no-op; it never panics.
panic unwinds the stack running deferred functions; a recover inside one of those deferred functions stops the unwinding and returns the panic value.
min, max, and clear require Go 1.21 or newer.

Go Built-in Functions Reference

Email me this result

How it works

Worked example

Notes