Go Developer interview questions

Go's predeclared basic types fall into boolean, numeric, and string categories.

• bool represents true or false values.
• Numeric types include signed and unsigned integers, floating-point numbers, and complex numbers.
• string represents an immutable sequence of bytes.

Both forms declare variables, but they differ in scope rules and type syntax.

• var works at package or function scope and may include an explicit type, an initializer, or both.
• A var declaration without an explicit type infers it from the initializer, while one without an initializer uses the type's zero value.
• := works only inside functions and always infers the declared variables' types.
• A multi-variable := may reuse variables from the same block only when at least one non-blank variable is new.

A zero value is the default value assigned when storage is created without an explicit initializer.

• Boolean values default to false, numeric values to 0, and strings to the empty string.
• Pointers, slices, maps, functions, channels, and interfaces default to nil.
• Every element of an array starts at the zero value of its element type.
• Every field of a struct starts at the zero value of its field type.

Go constants may be untyped or explicitly typed, and iota helps generate related constant values.

• An untyped constant keeps an abstract constant kind until a context requires a concrete type.
• A typed constant has the explicit type written in its declaration and must be representable by that type.
• Constant values are fixed at compile time and cannot be changed after declaration.
• Within a const block, iota starts at 0 and increases by 1 for each successive constant specification.

An explicit Go conversion applies the target type as T(value).

• Go does not implicitly convert between different numeric types such as int32 and int64.
• The source value must be convertible to the target type under the language rules.
• Converting a floating-point value to an integer discards its fractional part.
• Narrowing or changing numeric representations can lose range or precision.

A Go string stores a read-only sequence of bytes whose contents cannot be changed in place.

• A string may contain arbitrary bytes and is not required to contain valid UTF-8.
• Indexing a string returns the byte at that position.
• Slicing a string selects a byte range and produces another string value.
• Changing text requires constructing a new string, often through a []byte or []rune conversion.

byte and rune are predeclared aliases used for two different views of textual or binary data.

• byte is an alias for uint8 and represents one raw byte.
• rune is an alias for int32 and conventionally represents one Unicode code point.
• A single-quoted character literal produces a rune value.
• String indexing works with bytes, while range over a string decodes UTF-8 code points as runes.

For a string, len reports bytes rather than decoded Unicode code points.

• ASCII characters occupy one byte, so byte and rune counts match for ASCII-only strings.
• utf8.RuneCountInString counts the runes produced by UTF-8 decoding.
• Converting to []rune and taking len also counts decoded runes but creates a rune slice.
• A rune count is not always the count of user-perceived characters because one visible symbol may contain multiple code points.

A Go function can declare and return multiple values in a fixed order.

• The function signature lists all result types, and each return supplies matching values.
• A call with multiple results can assign them to the same number of variables.
• The blank identifier _ discards a value without creating a usable binding.
• Every other local variable must be used, so _ can explicitly ignore an unwanted result.

A named type declaration creates a distinct type, while a type alias gives another name to an existing type.

• type UserID int defines UserID as a new named type with int as its underlying type.
• Values of UserID and int generally require an explicit conversion when moved between those types.
• type UserID = int makes UserID identical to int for type identity and assignment.
• An alias does not create a separate type or a separate underlying representation.

An array has a fixed length in its type, while a slice is a flexible view of an underlying array.

• The length is part of an array type, so [3]int and [4]int are different types.
• Assigning an array copies all of its elements.
• A slice can change its length within its capacity and can grow with append.
• Assigning a slice copies its descriptor, so both slices can refer to the same elements.

A slice is described by a pointer to a backing array, a length, and a capacity.

• The pointer identifies where the slice's elements begin.
• The length is the number of elements currently accessible through the slice.
• The capacity is the number of elements available from the slice start to the end of the backing storage.
• Copying a slice value copies this descriptor rather than the underlying elements.

A nil slice has no backing storage reference, while an empty non-nil slice is initialized but contains no elements.

• Both can have length and capacity equal to zero.
• Only the nil slice compares equal to nil.
• append, len, cap, and range work with both kinds of slice.
• make([]T, 0) and []T{} produce empty non-nil slices.

The make function creates an initialized slice with a specified length and an optional capacity.

• make([]T, length) creates a slice whose capacity is at least its length.
• make([]T, length, capacity) sets both values, and capacity cannot be smaller than length.
• All elements within the initial length contain the zero value of T.
• make returns a slice value, not a pointer to a slice.

append returns a slice containing the original elements followed by the new elements.

• If capacity is sufficient, append can reuse the existing backing array.
• If capacity is insufficient, append allocates new backing storage and copies the elements.
• The returned slice must be used because its pointer, length, or capacity may differ.
• When storage is reused, other slices sharing that array may observe element changes.

A subslice normally shares the same backing array as the original slice.

• Changing a shared element through either slice is visible through the other.
• The subslice length is determined by the selected index range.
• Its capacity usually extends from the new start position to the original capacity limit.
• A full slice expression can set a smaller capacity limit for the subslice.

copy transfers elements from a source slice into an existing destination slice.

• It copies min(len(dst), len(src)) elements.
• It returns the number of elements copied.
• It does not grow the destination slice or change its length.
• It produces the correct result even when the source and destination overlap.

A map key type must support equality comparison with == and !=.

• Booleans, numbers, strings, pointers, channels, interfaces, arrays, and structs can be keys when their values are comparable.
• A struct is comparable only when all of its fields are comparable.
• Slices, maps, and functions cannot be map keys.
• Each key identifies at most one value in the map.

Reading an absent map key returns the zero value of the map's value type.

• A direct lookup has the form value := m[key].
• The comma-ok form value, ok := m[key] also reports whether the key exists.
• ok is false for an absent key and true for a present key.
• The boolean distinguishes an absent key from a present key storing a zero value.

A nil map can be read but must be initialized before storing entries.

• Reading a nil map returns the value type's zero value.
• Assigning an entry to a nil map causes a runtime panic.
• make(map[K]V) creates an initialized map that accepts assignments.
• delete(m, key) removes a key and is safe for absent keys and nil maps.