Fundamentals

Question 1

What is the default value of an uninitialized variable in Go?

Answer 1

The zero value, which depends on the type (e.g., 0 for integers, “” for strings, false for booleans).

Question 2

How do you declare a variable in Go without initializing it?

Answer 2

var x int (this sets x to the zero value of int, which is 0).

Question 3

What is the difference between := and var in Go?

Answer 3

:= is used for short variable declarations and can only be used inside functions, while var can be used both inside and outside functions.

Question 4

What does the defer keyword do in Go?

Answer 4

It defers the execution of a function until the surrounding function returns.

Question 5

Explain how slices work in Go.

Answer 5

A slice is a dynamically-sized, flexible view into the elements of an array. It references a part or all of an underlying array.

Question 6

How do you handle errors in Go?

Answer 6

Errors are handled using a return value, typically the last value returned by a function, and are checked with an if err != nil block.

Question 7

What is a Goroutine?

Answer 7

A Goroutine is a lightweight thread managed by the Go runtime, allowing concurrent execution of functions.

Question 8

How do you start a new Goroutine?

Answer 8

By prefixing a function call with the go keyword, e.g., go myFunction().

Question 9

How does Go manage memory?

Answer 9

Go has automatic memory management with garbage collection, freeing memory that is no longer referenced.

Question 10

What is a channel in Go?

Answer 10

A channel is a typed conduit through which Goroutines communicate with each other. Channels synchronize Goroutines’ execution.

Question 11

How do you send data to a channel?

Answer 11

Using the syntax ch <- value, where ch is the channel and value is the data to send.

Question 12

What is the purpose of the select statement in Go?

Answer 12

select allows a Goroutine to wait on multiple communication operations on channels and execute whichever is ready first.

Question 13

Can Go support inheritance?

Answer 13

No, Go does not support traditional inheritance but achieves similar behavior through composition using interfaces and structs.

Question 14

How are interfaces defined in Go?

Answer 14

Interfaces are defined as a set of method signatures. Any type that implements these methods satisfies the interface.

Question 15

What is a pointer in Go, and how do you declare one?

Answer 15

A pointer holds the memory address of a variable. It is declared with an asterisk (*), e.g., var p *int.

Question 16

How do you retrieve the value a pointer is pointing to in Go?

Answer 16

By dereferencing the pointer using the asterisk (*), e.g., *p retrieves the value stored at the memory address p points to.

Question 17

What is the difference between a slice and an array in Go?

Answer 17

An array has a fixed size defined at declaration, while a slice is a dynamically sized view into an array that can grow or shrink as needed.

Question 18

How do you create a slice from an array in Go?

Answer 18

By specifying a range, e.g., arr[1:4] creates a slice from the array arr containing elements at indices 1, 2, and 3.

Question 19

How do you append elements to a slice in Go?

Answer 19

Using the built-in append function, e.g., slice = append(slice, elem)

Question 20

What are Go’s built-in data types?

Answer 20

Basic types include int, float64, string, bool, and composite types include array, slice, struct, map, interface, and channel.

Question 21

What is the difference between make and new in Go?

Answer 21

make is used for initializing slices, maps, and channels, while new allocates memory but does not initialize the value.

Question 22

How do you define a struct in Go?

Answer 22

A struct is defined using the type keyword, followed by the struct name and fields.
Example:
~~~
type Person struct {
Name string
Age int
}
~~~

Question 23

How do you instantiate and use a struct in Go?

Answer 23

p := Person{Name: "John", Age: 30}  
fmt.Println(p.Name, p.Age)

Question 24

What does the go fmt tool do?

Answer 24

go fmt formats Go source code according to the standard style guidelines.

Question 25

What are the ways to declare constants in Go?

Answer 25

Constants are declared using the const keyword, and their values must be assigned at compile-time.
~~~
const Pi = 3.14
~~~

Question 26

What is the purpose of the iota keyword in Go?

Answer 26

iota is used to simplify constant declarations. It is reset to 0 at the start of each const block and increments automatically.
~~~
const (
A = iota
B = iota
)
~~~

Question 27

What is the purpose of the panic function in Go?

Answer 27

panic is used to stop the execution of a program when something unexpected happens. It typically signals unrecoverable errors.

Question 28

How do you recover from a panic in Go?

Answer 28

By using the recover function inside a deferred function. recover can catch a panic and prevent the program from crashing.

Question 29

How do you handle multiple return values in Go?

Answer 29

Go functions can return multiple values. They are returned as a comma-separated list.
~~~
func divide(a, b int) (int, error) {
if b == 0 {
return 0, fmt.Errorf(“division by zero”)
}
return a / b, nil
}
~~~

Question 30

What is the difference between passing by value and passing by reference in Go?

Answer 30

Passing by value creates a copy of the data and does not affect the original variable, while passing by reference (using pointers) allows the function to modify the original variable.

Question 31

How do you create a map in Go?

Answer 31

A map is created using the make function or a map literal.
~~~
m := make(map[string]int)
m[“key”] = 10
~~~

Question 32

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

Answer 32

By using the value-comma-ok idiom.
~~~
val, ok := m[“key”]
if ok {
fmt.Println(“Key exists”)
}
~~~

Question 33

How do you declare a function in Go?

Answer 33

Functions are declared using the func keyword followed by the name, parameters, and return type.
~~~
func add(a int, b int) int {
return a + b
}
~~~

Question 34

What is a method in Go, and how is it different from a function?

Answer 34

A method is a function with a receiver, which is the type it is associated with.
~~~
func (p Person) Greet() string {
return “Hello, “ + p.Name
}
~~~

Question 35

How do you define an anonymous function in Go?

Answer 35

An anonymous function is a function without a name.
~~~
func() {
fmt.Println(“Anonymous function”)
}()
~~~

Question 36

How do you define a function that returns another function in Go?

Answer 36

You return the function type as part of the return signature.
~~~
func adder(a int) func(int) int {
return func(b int) int {
return a + b
}
}
~~~

Question 37

What are variadic functions in Go?

Answer 37

A variadic function can accept any number of arguments of the same type.
~~~
func sum(nums …int) int {
total := 0
for _, num := range nums {
total += num
}
return total
}
~~~

Question 38

How do you convert a slice into variadic arguments in Go?

Answer 38

By using the … operator.
~~~
nums := []int{1, 2, 3}
sum(nums…)
~~~

Question 39

How do you use the range keyword with slices in Go?

Answer 39

range is used to iterate over elements in a slice.
~~~
for i, v := range slice {
fmt.Println(i, v)
}
~~~

Question 40

How do you prevent race conditions when working with Goroutines in Go?

Answer 40

Use channels or the sync.Mutex to synchronize access to shared variables between Goroutines.

Question 41

What does the sync.WaitGroup do in Go?

Answer 41

It is used to wait for a collection of Goroutines to finish executing.
~~~
var wg sync.WaitGroup
wg.Add(1)
go func() {
defer wg.Done()
// goroutine logic
}()
wg.Wait()
~~~

Question 42

What are Go’s built-in control flow statements?

Answer 42

Go includes standard control flow statements like if, for, switch, and select.

Question 43

How does Go handle switch statements differently than other languages?

Answer 43

Go’s switch does not require explicit break statements, as each case is automatically terminated unless the fallthrough keyword is used.

Question 44

What are Go’s looping constructs?

Answer 44

Go only has the for loop, which can be used in various ways:

Traditional loop: for i := 0; i < 10; i++ {}
While loop: for i < 10 {}
Infinite loop: for {}

Question 45

What is the difference between break and continue in Go loops?

Answer 45

break exits the loop entirely, while continue skips to the next iteration.

Question 46

How do you handle concurrent reads and writes to a map in Go?

Answer 46

Go’s maps are not thread-safe, so you should use a sync.Mutex or sync.RWMutex to handle concurrent access to maps.

Question 47

How do you check the type of an interface at runtime in Go?

Answer 47

By using a type assertion or a type switch.
~~~
value, ok := interfaceVar.(string)
~~~

Question 48

What does the blank identifier (_) do in Go?

Answer 48

The blank identifier is used to discard a value that you don’t need.

Question 49

How do you copy one slice to another in Go?

Answer 49

By using the copy function.
copy(dst, src)

Question 50

Can a slice hold different types of data in Go?

Answer 50

No, slices in Go are homogenous. They can only hold elements of the same type. However, you can use a slice of type interface{} to store different types.