Go Interview Questions and Answers

What is Go (Golang)?

Go is a statically typed, compiled programming language designed at Google by Robert Griesemer, Ken Thompson, and Rob Pike. It is known for its simplicity, efficiency, built-in concurrency features, and strong standard library.

Why was Go created? What are its key goals?

Go was created to address issues faced in large-scale software development at Google, such as slow build times, dependency management challenges, and difficulty in writing concurrent programs. Key goals included:
- Fast compilation.
- Ease of programming and readability.
- Strong support for concurrency.
- Memory safety.
- Efficient garbage collection.

Is Go a compiled or interpreted language?

Go is a compiled language. Go source code is compiled into machine code binaries.

Is Go statically or dynamically typed?

Go is a statically typed language. Variable types are checked at compile time.

What is the difference between `var` and `:=` for declaring variables?

var: Declares a variable with an optional initial value. If no initial value is provided, it's initialized with the zero value for its type. Can be used inside and outside functions.
```
var x int          // x is 0
var y int = 10     // y is 10
var z = "hello"    // z is "hello" (type inference)
```
:= (Short variable declaration): Declares and initializes a variable. The type is inferred from the initial value. Can only be used inside functions.
```
a := 20            // a is 20 (int)
b := "world"       // b is "world" (string)
```

What are the zero values for different data types in Go?

Numeric types (int, float, etc.): 0
bool: false
string: "" (empty string)
Pointers: nil
Slices: nil
Maps: nil
Channels: nil
Interfaces: nil
Structs: A struct with all its fields set to their respective zero values.

Explain the concept of packages in Go.

Packages are Go's way of organizing code. They provide modularity and encapsulation. Code within a package can access other code within the same package. To use code from another package, you need to import it. The `main` package is special; it's the entry point for executable programs.

What is the purpose of the `package main` declaration?

The package main declaration indicates that the package is an executable program, not a library. It must contain a func main() function, which is where the program execution begins.

How do you make a function or variable visible outside its package?

To make a function, variable, struct field, or type visible (exported) outside its package, its name must start with an uppercase letter.

What is `GOPATH`? (And how do Go Modules relate?)

Historically, GOPATH was an environment variable specifying the root of your Go workspace, where source code, compiled packages, and executable binaries were stored.
With Go Modules (introduced in Go 1.11 and the default since Go 1.16), GOPATH is less critical for dependency management. Modules manage dependencies on a per-project basis, independent of the workspace location. While GOPATH can still be used for installing tools, module-aware commands handle dependencies within the module directory.

What are Go Modules? Why are they important?

Go Modules are Go's dependency management system. They define the dependencies required by a specific project and their exact versions. They are important because they:
- Provide reproducible builds.
- Eliminate the need for a strict GOPATH structure.
- Make dependency management easier and more reliable.
- Support vendoring dependencies.

What are slices in Go? How are they different from arrays?

Slices are a dynamic, flexible view into the elements of an underlying array. They don't own data themselves but describe a contiguous section of an array.
Differences from arrays:
- Arrays have a fixed size determined at compile time. Slices have a dynamic size.
- Arrays are value types. Slices are reference types (they contain a pointer to an underlying array, length, and capacity).
- Arrays are less commonly used directly in Go code compared to slices.

Explain slice capacity and length.

Length: The number of elements currently in the slice (len(slice)).
Capacity: The number of elements in the underlying array, starting from the slice's first element, that the slice can access without needing to reallocate the underlying array (cap(slice)).

How do you create a slice?

Using a slice literal: mySlice := []int{1, 2, 3}
Slicing an array or another slice: mySlice := myArray[low:high], mySlice := anotherSlice[low:high:maxCap]
Using the make function: mySlice := make([]int, length, capacity) or mySlice := make([]int, length) (capacity defaults to length).

What happens when you append to a slice?

If the slice has enough capacity in its underlying array, the new elements are added, and the length is increased. The slice's underlying array remains the same.
If the slice does not have enough capacity, Go allocates a new, larger underlying array, copies the existing elements and the new elements to the new array, and the slice is updated to point to the new array.

What are maps in Go?

Maps are unordered collections of key-value pairs, where all keys in a given map are of the same type, and all values are of the same type. Keys must be comparable types (e.g., integers, strings, structs without slices/maps/functions).

How do you create a map?

Using a map literal: myMap := map[string]int{"apple": 1, "banana": 2}
Using the make function: myMap := make(map[string]int) or myMap := make(map[string]int, initialCapacity).

How do you check if a key exists in a map?

Use the "comma ok" idiom:

value, ok := myMap[key]
if ok {
    // Key exists, value is available
} else {
    // Key does not exist
}

How do you delete an element from a map?

Use the built-in delete function: delete(myMap, key).

What are structs in Go?

Structs are user-defined composite types that group together fields of different data types under a single name. They are used to represent records or objects with properties.

Explain struct embedding.

Struct embedding is Go's way of achieving composition. By embedding a struct within another struct (declaring a field with only the type name), the fields and methods of the embedded struct are promoted to the outer struct, allowing you to access them directly. This is often referred to as "anonymous fields" or "composition over inheritance".

What are methods in Go? How are they different from functions?

Methods are functions associated with a specific type (the receiver type). They are declared with a receiver argument before the function name.
Functions are general-purpose blocks of code that are not associated with a specific type.

Explain value receivers vs. pointer receivers for methods.

Value receiver: The method operates on a copy of the original value. Changes made to the receiver inside the method do not affect the original value.
```
func (p MyType) myMethod() { /* operates on a copy of p */ }
```
Pointer receiver: The method operates on the original value through its pointer. Changes made to the receiver inside the method *do* affect the original value.
```
func (p *MyType) myMethod() { /* operates on the original p */ }
```
Use pointer receivers when you need to modify the receiver or when the receiver is large to avoid copying overhead. Use value receivers when you only need to read from the receiver and don't need to modify it.

What are interfaces in Go?

Interfaces in Go are collections of method signatures. They define a contract: any type that implements all the methods specified in an interface implicitly satisfies that interface. Interfaces enable polymorphism in Go.

How does a type satisfy an interface in Go?

A type satisfies an interface simply by implementing all the methods declared in the interface, regardless of whether it explicitly declares that it implements the interface.

What is the empty interface (`interface{}` or `any`)?

The empty interface is an interface that has zero methods. Since every type implements zero methods, values of *any* type can be assigned to a variable of type interface{} or any. This is often used when you need to handle values of unknown or varying types, though it sacrifices type safety.

Explain type assertions and type switches.

Type assertion: Used to extract the underlying concrete value from an interface value and check its type.
```
value, ok := myInterface.(ConcreteType)
```

Type switch: A form of switch statement that allows you to check the type of an interface value against multiple possible types.

switch v := myInterface.(type) {
case int:
    // v is an int
case string:
    // v is a string
default:
    // v is another type
}

How does Go handle errors?

Go handles errors explicitly by returning error values as the last return value of a function. Functions that can fail typically return a result and an error. If the operation succeeds, the error is nil; otherwise, it's a non-nil error value.

What is the `error` interface?

The built-in error interface is defined as:
```
type error interface {
    Error() string
}
```
Any type that implements an Error() string method satisfies the error interface.

How do you create a custom error?

You can create a custom error by implementing the error interface.

type MyError struct {
    Message string
    Code int
}

func (e *MyError) Error() string {
    return fmt.Sprintf("Error %d: %s", e.Code, e.Message)
}

Or using errors.New("error message") for simple errors.
Or using fmt.Errorf("formatted error: %w", err) for wrapping errors (Go 1.13+).

What is the purpose of the `defer` keyword?

The defer keyword schedules a function call to be executed just before the surrounding function returns, regardless of whether the function returns normally or due to a panic. It's commonly used for cleanup tasks like closing files, unlocking mutexes, or closing network connections.

Can you explain the order of execution for multiple `defer` statements?

Deferred functions are executed in Last-In, First-Out (LIFO) order. The last defer statement encountered in a function is the first one to be executed when the function returns.

What is `panic`? When should you use it?

panic is a built-in function that stops the normal execution of the current goroutine. When a function panics, deferred functions are executed, and then the program crashes unless recover is used.
panic should be used for truly exceptional, unrecoverable errors, such as programming errors (e.g., accessing an out-of-bounds slice index) or situations where the program cannot reasonably continue. For expected errors (like file not found), return an error.

What is `recover`? When should you use it?

recover is a built-in function that is used inside a deferred function to regain control of a panicking goroutine. It stops the panic sequence and returns the value passed to the panic call.
recover is primarily used to handle panics in server-level code or specific scenarios where you want to gracefully handle an unexpected panic rather than letting the entire program crash. It's not typically used for general error handling.

Explain the concept of concurrency in Go.

Concurrency in Go refers to the ability of a program to handle multiple tasks seemingly at the same time. Go achieves this through goroutines and channels, based on the Communicating Sequential Processes (CSP) model.

What are goroutines?

Goroutines are lightweight, independently executing functions. They are analogous to threads but are managed by the Go runtime scheduler, which is much more efficient than the operating system's thread scheduler. You start a goroutine by using the go keyword before a function call.

What are channels? Why are they important for concurrency in Go?

Channels are typed conduits through which you can send and receive values with other goroutines. They provide a safe way for goroutines to communicate and synchronize.
They are important because Go encourages communication by sharing memory (using channels) rather than sharing memory by communicating (using mutexes). Channels help prevent race conditions and simplify concurrent programming.

Explain buffered vs. unbuffered channels.

Unbuffered channel: A channel with a capacity of zero. Sending on an unbuffered channel blocks until a receiver is ready, and receiving blocks until a sender is ready. They synchronize goroutines by ensuring that both the sender and receiver are ready at the same time.
Buffered channel: A channel with a capacity greater than zero. Sending on a buffered channel blocks only if the buffer is full. Receiving blocks only if the buffer is empty. They allow for asynchronous communication up to the buffer size.

What is the purpose of the `select` statement?

The select statement is used with channels to wait on multiple communication operations. It allows a goroutine to wait until one of several send or receive operations is ready and then proceeds with that operation. If multiple operations are ready, one is chosen pseudo-randomly.

What are Mutexes (`sync.Mutex`)? When would you use them instead of channels?

A Mutex (Mutual Exclusion) is a synchronization primitive used to protect shared resources from concurrent access. It provides Lock() and Unlock() methods. Only one goroutine can hold the lock at a time.
You would use Mutexes when multiple goroutines need to modify shared data in memory, and channels are not suitable for coordinating that specific access pattern. For example, protecting a shared map or a counter variable.

What is a WaitGroup (`sync.WaitGroup`)?

A WaitGroup is used to wait for a collection of goroutines to finish. It acts as a counter:
- Add(n): Increments the counter by n.
- Done(): Decrements the counter by 1.
- Wait(): Blocks until the counter becomes zero.

How do you prevent a race condition in Go?

Race conditions occur when multiple goroutines access and modify shared data concurrently without proper synchronization. You can prevent them by:
- Using channels to communicate and synchronize access to data (preferred Go approach).
- Using synchronization primitives like Mutexes (sync.Mutex) to protect shared resources.
- Using atomic operations (sync/atomic) for simple operations on basic types.

What is the Go garbage collector?

Go has an automatic garbage collector (GC) that reclaims memory that is no longer being used by the program. It runs concurrently with the program and aims for low latency pauses.

How do you write tests in Go?

Go has a built-in testing framework in the testing package.
Create a file ending with _test.go in the same package as the code you want to test.
Write test functions that start with Test and take a *testing.T parameter (e.g., func TestMyFunction(t *testing.T)).
Use methods like t.Error(), t.Errorf(), t.Fail(), t.Fatal(), t.Fatalf() to report test failures.
Run tests using the go test command.

What is a table-driven test?

A table-driven test is a common pattern in Go testing where you use a slice of structs (the "table") to define multiple test cases with different inputs and expected outputs. You then loop through the table, running the same test logic for each case. This makes it easy to add new test cases and improves test readability and maintainability.

How do you write benchmarks in Go?

Create a file ending with _test.go.
Write benchmark functions that start with Benchmark and take a *testing.B parameter (e.g., func BenchmarkMyFunction(b *testing.B)).
Inside the benchmark function, use a loop (b.N) to run the code being benchmarked multiple times: for i := 0; i < b.N; i++ { ... }.
Run benchmarks using the command go test -bench=..

What is the purpose of the `go fmt` command?

go fmt automatically formats Go source code according to the standard Go style. It helps ensure code consistency across projects and teams.

What is the purpose of the `go vet` command?

go vet is a static analysis tool that examines Go source code for potential errors or suspicious constructs (e.g., unreachable code, incorrect format strings).

What is the purpose of the `go generate` command? (Advanced)

go generate is a command that scans Go source files for lines starting with //go:generate. These lines are directives that tell go generate to run a specific command. It's used for automating code generation tasks (e.g., generating stringer methods, parsing grammar files).

Explain the difference between `len()` and `cap()` for slices. (Revisited)

len(s) returns the number of elements currently in slice s.
cap(s) returns the number of elements in the underlying array of slice s, starting from the first element of s, that the slice can accommodate without reallocating.

What is the difference between `nil` slices and empty slices?

Nil slice: A slice variable that has not been initialized or has been explicitly set to nil. Its underlying array is nil, and its length and capacity are both 0. A nil slice can be used with len(), cap(), and append().
```
var mySlice []int // nil slice
```
Empty slice: A slice that has been initialized but contains no elements. Its underlying array is not nil (though it might point to a zero-length array), and its length and capacity are both 0.
```
mySlice := []int{}
mySlice := make([]int, 0)
```
Functionally, for most purposes, nil and empty slices behave similarly (e.g., len and cap are 0), but they are represented differently internally.

What is struct tag? How is it used?

A struct tag is a string literal associated with a struct field. It provides metadata about the field that can be accessed at runtime using reflection.
They are commonly used by encoding/decoding packages (like encoding/json, encoding/xml) to specify how the field should be represented in the encoded output (e.g., the JSON key name).

type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age,omitempty"` // omitempty means exclude if zero value
}

What is the use of the blank identifier (`_`) in Go?

The blank identifier is used when you need to assign a value to a variable but don't intend to use that variable. This is often used to:
- Ignore multiple return values from a function.
- Prevent the compiler from complaining about unused imported packages or unused declared variables.
- Import a package solely for its side effects (e.g., registering a database driver).

Explain how variadic functions work.

A variadic function is a function that accepts a variable number of arguments of the same type. The variadic parameter is specified with an ellipsis (...) before the type. Inside the function, the variadic parameter is treated as a slice of that type.
```
func Sum(nums ...int) int {
    total := 0
    for _, num := range nums {
        total += num
    }
    return total
}
```

How do you pass arguments to a variadic function if you already have a slice?

You can pass a slice to a variadic function by appending ... to the slice name when calling the function:
```
mySlice := []int{1, 2, 3, 4}
result := Sum(mySlice...) // Pass slice elements as individual arguments
```

What is the difference between a pointer and a value?

Value: A variable that holds the actual data. Copying a value variable creates a new copy of the data.
Pointer: A variable that holds the memory address of another variable. Copying a pointer variable copies the memory address, not the data itself. Multiple pointers can point to the same underlying data.

When would you use pointers?

To modify a value that is outside the current function's scope.
To avoid copying large data structures (structs, arrays) when passing them to functions or methods.
When working with linked data structures (like linked lists or trees).

What is the purpose of the `new` keyword?

The new keyword allocates memory for a value of a given type and returns a pointer to the allocated, zero-valued memory. It's less commonly used than taking the address of a literal or existing variable.
```
p := new(int) // p is a pointer to an int, initialized to 0
```

What is the purpose of the `make` keyword?

The make keyword is used to create slices, maps, and channels. It allocates the underlying data structure and initializes it.

s := make([]int, 5)      // creates a slice of 5 ints
m := make(map[string]int) // creates an empty map
c := make(chan int)      // creates an unbuffered channel

What's the difference between `new(T)` and `make(T)`?

new(T): Allocates zeroed storage for a value of type T and returns a pointer of type *T. Works for any type.
make(T): Allocates and initializes an object of type T (slices, maps, channels). It's specific to these types because they require internal data structures to be initialized before use. It returns an initialized (non-zero) value of type T, not a pointer.

Explain the concept of "composition over inheritance" in Go.

Go does not have traditional class-based inheritance. Instead, it promotes "composition over inheritance" through struct embedding. By embedding structs, you can compose new types by including the functionality of existing types, achieving code reuse and flexibility without the complexities of inheritance hierarchies.

What is the `context` package used for? (Advanced)

The context package provides a way to carry request-scoped values, cancellation signals, and deadlines across API boundaries, especially in concurrent operations, server requests, and distributed systems. It's used to manage the lifecycle of goroutines.

How can you signal cancellation to a goroutine? (Advanced)

You can use the context package. Create a Context that supports cancellation (e.g., using context.WithCancel). Pass this context to the goroutine. The goroutine should listen on the context's Done() channel. When the cancel function is called on the context, the Done() channel is closed, signaling the goroutine to stop.

What is reflection in Go? (Advanced)

Reflection is the ability of a program to examine and modify its own structure and behavior at runtime. Go's reflect package provides functions to inspect the type and value of variables, call methods, and manipulate data indirectly. It's often used in serialization/deserialization, testing, and generic programming.

What are the types of reflection objects in Go? (Advanced)

reflect.Type: Represents the static type of a value.
reflect.Value: Represents the dynamic value of a variable.

Is using reflection recommended for common tasks?

Generally, no. Reflection is powerful but should be used sparingly. It can be slower than direct method calls, bypasses type safety (potentially leading to runtime panics), and can make code harder to read and maintain. Go's type system and interfaces are usually sufficient for most tasks.

What is the purpose of the `init` function?

The init function is a special function in Go that is executed automatically when a package is initialized. A package can have multiple init functions (in different files), and they are executed in the order the files are presented to the compiler. init functions are typically used for setting up package-level variables, registering in data structures, or performing one-time initialization tasks.

What is the execution order of `init` and `main` functions?

init functions are executed before the main function. If a package imports other packages, the imported packages' init functions are executed first (in dependency order), followed by the importing package's init functions, and finally the main function.

What is the difference between `go run` and `go build`?

go run : Compiles and runs the specified Go file(s) as a temporary executable. It doesn't produce a permanent executable file.
go build []: Compiles the specified package (or the current package if none is specified) and produces an executable binary in the current directory (for main packages) or a package archive (for library packages).

How do you cross-compile a Go program?

Go has excellent built-in support for cross-compilation. You can set the GOOS (target operating system) and GOARCH (target architecture) environment variables before running go build.
```
GOOS=linux GOARCH=amd64 go build -o myapp_linux .
```

What is the purpose of the `fmt` package?

The fmt package implements formatted I/O functions (like Printf, Sprintf, Scanf) for input and output operations, similar to C's printf and scanf.

How do you read input from the console in Go?

You can use functions from the fmt package like fmt.Scan(), fmt.Scanln(), or fmt.Scanf(). For more flexible input, you might use the bufio package.

How do you work with JSON in Go?

Go's standard library provides the encoding/json package for encoding (marshalling) and decoding (unmarshalling) JSON data. You typically use structs to represent the JSON structure and use struct tags to control mapping between struct fields and JSON keys.

Explain marshalling and unmarshalling in the context of JSON.

Marshalling: The process of converting a Go data structure (like a struct) into its JSON representation (a byte slice). Done using json.Marshal().
Unmarshalling: The process of converting a JSON representation (a byte slice) into a Go data structure. Done using json.Unmarshal().

How do you make a struct field ignored during JSON marshalling/unmarshalling?

Use the JSON struct tag with the - option:

type MyStruct struct {
    Field1 string `json:"field1"`
    IgnoredField string `json:"-"` // This field will be ignored
}

How do you make a struct field optional in JSON (omitempty)?

Use the JSON struct tag with the omitempty option:

type MyStruct struct {
    Field1 string `json:"field1"`
    OptionalField int `json:"optional_field,omitempty"` // Excluded if zero value (0 for int)
}

What is the purpose of the `io` package?

The io package provides basic interfaces and helper functions for I/O primitives, such as Reader, Writer, Closer, and ReadWriter. Many other packages that perform I/O (like os, net, bufio) build upon the interfaces defined in the io package.

What is the purpose of the `os` package?

The os package provides a platform-independent interface to operating system functionality, such as file operations, environment variables, process management, and command-line arguments.

How do you read command-line arguments in Go?

Command-line arguments are available in the os.Args slice (a []string). os.Args[0] is the program name, and subsequent elements are the arguments.

How do you read environment variables in Go?

Use functions from the os package, such as os.Getenv("VARIABLE_NAME") to get the value of a specific variable, or os.LookupEnv("VARIABLE_NAME") to check if a variable is set and get its value safely.

What is the purpose of the `net/http` package?

The net/http package provides implementations for HTTP clients and servers. It's a fundamental package for building web applications and making HTTP requests in Go.

How do you create a simple HTTP server in Go?

Use http.HandleFunc to register a handler function for a specific URL path.

Use http.ListenAndServe to start the server and listen on a port.

func handler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, world!")
}

func main() {
    http.HandleFunc("/", handler)
    log.Fatal(http.ListenAndServe(":8080", nil))
}

How do you make an HTTP GET request in Go?

Use http.Get(url). This returns an *http.Response and an error. Remember to close the response body.

resp, err := http.Get("https://example.com")
if err != nil {
    log.Fatal(err)
}
defer resp.Body.Close()
// Read the response body...

What is the purpose of the `defer resp.Body.Close()` pattern?

HTTP response bodies implement the io.ReadCloser interface. You need to close the response body to release resources (like the underlying network connection). Using defer resp.Body.Close() ensures that the body is closed even if there are errors during reading.

What is the difference between concurrency and parallelism? (Revisited)

Concurrency: The ability to deal with multiple tasks at the same time (interleaving execution). A single-core processor can be concurrent.
Parallelism: The ability to execute multiple tasks *simultaneously*. Requires multiple processing cores.
Go's concurrency features (goroutines and channels) enable concurrent programming, which can then be executed in parallel by the Go runtime on multi-core processors.

What is the Go runtime scheduler?

The Go runtime includes a scheduler that manages goroutines. It maps goroutines to OS threads (typically a small number of OS threads per logical processor, controlled by GOMAXPROCS). The scheduler is responsible for multiplexing goroutines onto these threads, allowing for efficient switching and execution of a large number of goroutines.

What is `GOMAXPROCS`?

GOMAXPROCS is an environment variable (or runtime setting) that controls the number of operating system threads that the Go runtime can use to execute user-level Go code. By default, it's set to the number of logical CPUs available. Setting it to a value greater than 1 allows Go programs to run goroutines in parallel.

What is a data race? How can you detect them?

A data race occurs when two or more goroutines access the same memory location concurrently, and at least one of the accesses is a write operation, without proper synchronization. This can lead to unpredictable behavior and bugs.
You can detect data races using Go's built-in race detector by running your program or tests with the -race flag: go run -race myapp.go or go test -race ..

What is the purpose of the `sync.Map`? (Advanced)

sync.Map is a concurrent map implementation in the sync package. It's designed for use cases where keys are only ever written once but read many times, or where disparate goroutines read, write, and overwrite disjoint sets of keys. For general-purpose concurrent maps, you typically use a regular map protected by a sync.RWMutex.

What is the purpose of the `sync.Pool`? (Advanced)

sync.Pool is a type that provides a pool of temporary objects that can be reused. It's useful for reducing memory allocation and garbage collection pressure for frequently created and discarded objects, such as buffer pools.

Explain the concept of embedded types and method promotion. (Revisited)

When you embed a type (e.g., a struct) within another struct, the fields and methods of the embedded type are "promoted" to the outer struct. This means you can access them directly on the outer struct instance as if they were declared directly in the outer struct. If there are name conflicts, the outer struct's fields/methods take precedence.

What is the difference between `nil` and zero value?

Zero value: The default value assigned to a variable when it is declared without an explicit initial value. Each type has a specific zero value (0, "", false, nil, etc.).
Nil: A special value that represents the absence of a value or a pointer for certain types (pointers, slices, maps, channels, interfaces, functions). It indicates that the variable does not point to a valid underlying data structure or object.

Can a nil slice be appended to?

Yes, a nil slice is equivalent to an empty slice for most purposes and can be appended to. The append function handles nil slices correctly.

Can a nil map be written to?

No, writing to a nil map will cause a panic at runtime. You must initialize a map using make() or a map literal before writing to it. Reading from a nil map returns the zero value for the element type.

Can a nil channel be used for sending or receiving?

Sending to a nil channel blocks indefinitely.
Receiving from a nil channel blocks indefinitely.
Closing a nil channel causes a panic.

What is the difference between `append(slice, element)` and `copy(dest, src)`?

append: Adds elements to the end of a slice. It might reallocate the underlying array if needed.
copy: Copies elements from a source slice (src) to a destination slice (dest). It copies the minimum of len(src) and len(dest) elements. It does not reallocate.

What happens if you try to access an element outside the bounds of a slice or array?

Accessing an element outside the bounds of a slice or array (using an index less than 0 or greater than or equal to the length) will result in a runtime panic: "index out of range".

What are Go's built-in data structures?

Arrays
Slices
Maps
Structs

What is the purpose of the `defer` statement with a function call that returns an error?

It ensures that cleanup operations (like closing files) are performed even if the function encounters an error and returns early.
```
f, err := os.Open("file.txt")
if err != nil {
    return err
}
defer f.Close() // Ensure file is closed

// ... process file ...
```

How do you read data from an `io.Reader`?

Use the Read([]byte) (n int, err error) method. It attempts to fill the provided byte slice with data from the reader. It returns the number of bytes read and an error (io.EOF at the end of the stream, or another error).

How do you write data to an `io.Writer`?

Use the Write([]byte) (n int, err error) method. It attempts to write the contents of the byte slice to the writer. It returns the number of bytes written and an error.

What is the purpose of the `ioutil` package? (Note: many functions moved to `io` and `os` in Go 1.16+)

The io/ioutil package (now largely deprecated in favor of io and os) provided utility functions for I/O operations, such as reading the entire content of a file (ReadFile), writing data to a file (WriteFile), and reading all data from an io.Reader (ReadAll).

How do you read an entire file into memory?

Use os.ReadFile("filename") (Go 1.16+) or ioutil.ReadFile("filename") (older versions). This returns a byte slice containing the file's content and an error.

How do you write data to a file?

Use os.WriteFile("filename", data, perm) (Go 1.16+) or ioutil.WriteFile("filename", data, perm) (older versions). This writes the byte slice data to the file with the specified permissions perm.
Alternatively, open the file using os.Create or os.OpenFile, get an *os.File (which implements io.Writer), and use its Write method. Remember to defer file.Close().

What is a named return value?

Named return values in a function are declared at the beginning of the function signature. They are treated as local variables and are initialized to their zero values. A bare return statement in the function will return the current values of the named return variables.
```
func divide(a, b int) (result int, err error) {
    if b == 0 {
        err = errors.New("division by zero")
        return // Returns zero value for result and the set err
    }
    result = a / b
    return // Returns the calculated result and nil err
}
```

When might you use named return values?

For clarity, especially when a function returns multiple values.
To simplify simple error handling where the error variable is consistently named (e.g., err).
However, overuse can make code less readable if the function logic is complex.

What is the purpose of the `time` package?

The time package provides functionality for working with time, including measuring time, manipulating time values, formatting time, and parsing time strings.

How do you measure the execution time of a function?

You can get the current time before the function call, get the time after, and calculate the difference using the time package.
```
start := time.Now()
// Call function to measure
duration := time.Since(start)
fmt.Printf("Function took %s\n", duration)
```

How do you parse a time string in Go?

Use the time.Parse(layout, value) function. The layout string specifies the expected format of the time string value using a specific reference time (Mon Jan 2 15:04:05 MST 2006 or 01/02 03:04:05PM '06 - known as the "magic date").

What is the purpose of the `log` package?

The log package provides a simple logging interface, primarily to standard error. It offers functions for printing messages with timestamps and other formatting.

How do you define a constant in Go?

Use the const keyword. Constants can be character, string, boolean, or numeric values. They are evaluated at compile time.
```
const Pi = 3.14
const Greeting = "Hello"
```

What is `iota`?

iota is a predeclared identifier used with constants to generate a sequence of increasing integer values. It starts at 0 in each const block and increments by 1 for each subsequent constant specification.
```
const (
    A = iota // A = 0
    B        // B = 1
    C        // C = 2
)

const (
    D = iota // D = 0 (iota resets in a new const block)
    E = 100
    F = iota // F = 2
)
```

What are pointers to pointers? (Advanced)

A pointer to a pointer is a variable that stores the memory address of another pointer variable. Declared using double asterisks (**T).
```
x := 10
p := &x   // p is a pointer to x
pp := &p  // pp is a pointer to p
```

What is the purpose of the `go doc` command?

go doc displays the documentation for a package or symbol (function, type, variable, constant). It extracts documentation comments (comments starting with the symbol's name) from the source code.

What is the purpose of the `go get` command? (And how it works with Modules)

go get is used to add a dependency to the current module. With Go Modules, it downloads the specified module and its dependencies, updates the go.mod file, and (if necessary) updates the go.sum file.

What is the purpose of the `go mod tidy` command?

go mod tidy adds any missing module requirements needed for the current module's builds and removes any requirements that are no longer needed. It cleans up the go.mod file.

What is the purpose of the `go mod vendor` command?

go mod vendor copies all the required dependencies into a vendor directory in the module's root. This allows for building the project without needing to download dependencies from the network (if using the -mod=vendor build flag).

What is the difference between `error` and `panic`? (Revisited)

error: Used for expected, recoverable issues. Functions return an error value to indicate failure. Callers are expected to check and handle the error.
panic: Used for unexpected, unrecoverable issues that indicate a program bug or a situation where the program cannot continue. It stops the current goroutine's execution.

Can you have multiple `main` functions in a Go project?

Yes, but only one main function is allowed per executable program. A project can contain multiple packages, and each package intended to be an executable would have its own package main and func main(). When building, you specify which package to build as the executable.

What is the purpose of the `init` function vs. a regular function called from `main`?

init functions are executed automatically by the Go runtime before main. They are guaranteed to run once per package initialization.
Regular functions called from main are executed only when explicitly called within the program's logic.
init is suitable for package-level setup that must happen before any other code in the package runs.

How do you handle signals (like SIGINT or SIGTERM) in Go? (Advanced)

Use the os/signal package. You can create a channel and notify it of incoming signals using signal.Notify(c, signals...). Then, you can receive from this channel in a goroutine to handle the signals.

What is the purpose of the `sync/atomic` package? (Advanced)

The sync/atomic package provides low-level atomic operations on basic data types (like integers and pointers). These operations are guaranteed to be executed as a single, indivisible instruction by the CPU, making them safe for concurrent access without needing mutexes for simple operations.

When would you use atomic operations instead of a mutex?

Use atomic operations for simple operations (incrementing a counter, loading/storing a value) on basic types when you need maximum performance and minimal overhead. For more complex operations involving multiple steps or data structures, a mutex is typically required.

What is the difference between passing a slice by value and by reference?

A slice is a struct containing a pointer to an underlying array, a length, and a capacity. When you pass a slice to a function:
- By value: A copy of the slice header (the struct) is passed. Both the original slice and the copy point to the *same* underlying array. Modifications to the *elements* of the slice within the function will affect the original slice's elements. However, changes to the slice header itself (like appending which causes reallocation) will *not* affect the original slice's header.
- By reference (using a pointer to a slice): A pointer to the slice header is passed. The function can modify the original slice header itself (e.g., change its length or capacity, or make it point to a new underlying array after appending).

What is the purpose of the `recover()` return value? (Revisited)

If a goroutine is panicking, calling recover() within a deferred function will stop the panic sequence and return the value that was passed to the panic() call. If the goroutine is not panicking, recover() returns nil.

Can you explain goroutine leakage? How can you prevent it? (Advanced)

A goroutine leak occurs when a goroutine is started but never finishes its execution, often because it's blocked indefinitely (e.g., waiting to send on a channel that no one is receiving from, or waiting to receive from a channel that no one is sending to). This consumes memory and resources.
Prevent leaks by:
- Ensuring goroutines finish their work or have a mechanism to exit (e.g., listening on a cancellation channel from the context package).
- Using select statements with a default case or timeouts to avoid indefinite blocking on channels.
- Using WaitGroups to ensure all expected goroutines complete.

What are channels of channels? (Advanced)

Channels can carry values of any type, including other channels. A channel of channels (e.g., chan chan int) allows you to send and receive channels themselves between goroutines. This can be used in complex coordination patterns.

What is the purpose of the `close()` function for channels?

close() is used to signal that no more values will be sent on a channel. Receiving from a closed channel will return the zero value for the channel's type immediately, without blocking, and the "ok" value in the comma-ok idiom will be false. Sending on a closed channel will cause a panic.

What happens when you receive from a closed channel? (Revisited)

Receiving from a closed channel will immediately return the zero value for the channel's element type. The second return value (the "ok" value) will be false, indicating that the channel is closed and the value received is the zero value.

What is the purpose of the `range` keyword with channels?

You can use a for...range loop to receive values from a channel until the channel is closed. The loop automatically terminates when the channel is closed and all sent values have been received.
```
for value := range myChannel {
    // Process value
}
// Loop exits when myChannel is closed
```

What is the difference between `fmt.Print`, `fmt.Println`, and `fmt.Printf`?

fmt.Print: Prints its arguments, using default formatting.
fmt.Println: Prints its arguments, using default formatting, and adds a newline at the end.
fmt.Printf: Prints its arguments according to a format specifier string (similar to C's printf).

What is the purpose of the `go build -ldflags` option? (Advanced)

-ldflags allows you to pass flags to the linker. Common uses include:
- Setting build information (version, build date) into variables using -X.
- Stripping debugging symbols to reduce binary size.

How do you embed static files (like HTML, CSS, images) into a Go binary? (Advanced)

Prior to Go 1.16, you typically used external tools (like go-bindata or statik) to convert files into Go code (byte slices or strings).
Since Go 1.16, the standard library provides the embed package and the //go:embed directive to embed files and directories directly into the compiled binary.

What is the purpose of the `interface{}` (or `any`) type assertion with the comma-ok idiom? (Revisited)

It's used to check if a value stored in an interface{} variable is of a specific concrete type and, if so, extract that value safely. The "ok" boolean indicates whether the assertion was successful.

What is the purpose of the `go tool trace` command? (Advanced)

go tool trace is used to visualize the execution of a Go program. You can generate a trace file using go run -trace trace.out myapp.go or within your code using the runtime/trace package. The trace shows goroutine activity, garbage collection events, and other runtime information, which is helpful for debugging performance issues and concurrency problems.

What are the common ways to optimize Go code? (Advanced)

Profiling (using pprof) to identify bottlenecks (CPU, memory).
Using the race detector to find concurrency issues.
Reducing unnecessary memory allocations (to reduce GC pressure).
Using appropriate data structures and algorithms.
Using sync.Pool for frequently used temporary objects.
Minimizing expensive I/O operations.
Optimizing critical code paths based on benchmarks.

Explain the concept of "escape analysis" in Go. (Advanced)

Escape analysis is a compiler optimization that determines whether a variable's memory must be allocated on the heap or if it can safely be allocated on the stack. If a variable's lifetime extends beyond the function where it's declared (e.g., its address is returned or stored in a global variable), it "escapes" to the heap. Otherwise, it can be allocated on the stack, which is generally faster.

What is the purpose of the `go build -trimpath` option? (Go 1.13+)

go build -trimpath removes file system path information from the compiled executable, making builds more reproducible and less sensitive to the build environment's directory structure.

What is the purpose of the `go mod download` command?

go mod download downloads the modules listed in the go.mod file to the local module cache. This is useful for ensuring dependencies are available offline or for inspection.

What is the difference between `go build` and `go install`?

go build compiles the package and places the resulting executable (for main packages) or package archive (for library packages) in the current directory.
go install compiles the package and places the resulting executable (for main packages) or package archive (for library packages) in the directory specified by GOPATH/bin or GOBIN (if set). It's typically used for installing commands or libraries for use by other Go programs. With Go Modules, go install can also install commands directly from VCS repositories.

What is the purpose of the `go generate` directive format? (Revisited)

The directive is //go:generate command arguments. It tells the go generate tool to run the specified command with the given arguments. The command is run from the directory containing the source file with the directive.

How do you include build information (like version) in a Go binary? (Revisited)

Declare a variable in your code (often in the main package or a dedicated version package).
```
var Version string
```
Use the -ldflags "-X 'path/to/variable=value'" option with go build or go install.
```
go build -ldflags "-X 'main.Version=v1.2.3'" .
```

What is the purpose of the `go test -cover` command?

go test -cover runs your tests and reports the test coverage percentage (the percentage of statements in your code that are executed by the tests).

What is the purpose of the `go test -coverprofile cover.out` command?

This runs your tests and writes the coverage profile data to the specified file (e.g., cover.out). You can then use go tool cover -html=cover.out to generate an HTML report showing which lines were covered.

What are embedded file systems in Go? (Go 1.16+) (Revisited)

Using the embed package and the //go:embed directive, you can embed the contents of files or directories directly into your Go binary. This allows you to distribute a single executable file that includes all necessary assets (templates, static files, etc.). The embedded content is accessible via the fs.FS interface.

What is the purpose of the `recover()` and `panic()` mechanism? (Revisited)

The panic/recover mechanism is Go's way of handling unexpected runtime errors. panic signals an abnormal, usually unrecoverable, situation. recover (used in a deferred function) allows you to catch a panic and potentially handle it gracefully or log it before the program terminates. It's not for typical error handling.

What is the difference between a channel and a slice?

Slice: A dynamic array, used to store collections of elements. It's a data structure for holding multiple values.
Channel: A communication mechanism used for sending and receiving values between goroutines. It's a synchronization and communication tool.

Can you send and receive nil on a channel?

You can send and receive nil on a channel if the channel's element type is a type that can be nil (e.g., pointers, slices, maps, channels, interfaces, functions). You cannot send or receive nil on channels whose element type is a value type (e.g., int, string, struct).

What is the purpose of the `sync.Once` type? (Advanced)

sync.Once is a type that guarantees that a function will be executed exactly once, regardless of how many goroutines call its Do method. It's commonly used for one-time initialization tasks.

var once sync.Once

func initConfig() {
    // Expensive initialization
}

func GetConfig() {
    once.Do(initConfig) // initConfig will be called only the first time Do is called
    // ... use config ...
}

What is the purpose of the `context.TODO()` and `context.Background()` functions? (Advanced)

context.Background(): Returns a non-nil, empty Context. It's typically used at the top level of your program or in tests where the context is not derived from an incoming request. It's the root of a Context tree.
context.TODO(): Also returns a non-nil, empty Context. It's used when you are unsure about which Context to use or when the function is being refactored to accept a Context but doesn't yet have one. It's a placeholder indicating that a proper Context should be passed later.

What is the purpose of the `io.Reader` and `io.Writer` interfaces? (Revisited)

They are fundamental interfaces in Go for abstracting input and output operations.
- io.Reader: Represents a source from which data can be read. Any type implementing the Read([]byte) (n int, err error) method satisfies this interface.
- io.Writer: Represents a destination to which data can be written. Any type implementing the Write([]byte) (n int, err error) method satisfies this interface.

Why are interfaces so important in Go?

Interfaces promote decoupling and flexibility. By programming against interfaces rather than concrete types, you can easily swap out implementations, make your code more testable, and enable polymorphism. They are a cornerstone of Go's design philosophy.

Go Tutorials

Go Interview