Go Interview Questions

Go, also known as Golang, is a statically typed, open-source programming language developed by Google. It is designed for efficiency, simplicity, and concurrency, making it ideal for system programming, web development, and cloud applications.

Golang is known for its fast execution speed, built-in concurrency, garbage collection, and easy-to-read syntax. Compared to languages like Python or Java, it provides better performance and compilation speed, making it suitable for scalable applications.

A package in Go is a collection of related Go files grouped together to promote code reusability and modularity. The main package is essential for executable programs, while others are used as libraries.

The scope of a variable defines the areas in which it can be accessed. In Go, variables can have block scope (inside functions or loops), package scope (accessible across files in the same package), or global scope (accessible throughout the program).

Yes, Go allows multiple variable declarations in one line:

var x, y, z = 150, "TopfreeCorse", true

A slice provides a dynamic and flexible view of an underlying array. Unlike arrays, slices can change in size by expanding or shrinking.

Pointers store the memory address of a variable. They enable efficient memory management and modification of variables by reference.

Go uses a simplified for loop:

for i := 0; i < 10; i++ {
    fmt.Println(i)
}

It can also be used as a while loop by omitting the initialization and increment.

Yes, Go supports returning multiple values:

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

Channels facilitate safe communication between goroutines, preventing race conditions:

ch := make(chan int)
go func() { ch <- 10 }()
fmt.Println(<-ch)

Interfaces define method sets without implementation, allowing polymorphism and flexibility in Go programs.

Use the comma-ok idiom:

val, exists := myMap["key"]
if exists {
    fmt.Println("Key exists:", val)
}

Go compiles directly to machine code, has efficient garbage collection, and supports lightweight concurrency through goroutines.

Type assertion retrieves the concrete type from an interface:

var i interface{} = "hello"
s := i.(string)
fmt.Println(s)

Using reflect or type switches:

import "reflect"
fmt.Println(reflect.TypeOf(myVar))

Variadic functions accept multiple arguments of the same type:

func sum(nums ...int) int {
    total := 0
    for _, num := range nums {
        total += num
    }
    return total
}

• byte: Alias for uint8, represents a single ASCII character.
• rune: Alias for int32, represents Unicode characters.

• Slices: copy(dest, src)
• Maps: Manually iterate and copy key-value pairs.

Use sort.Slice():

sort.Slice(persons, func(i, j int) bool {
    return persons[i].Age < persons[j].Age
})

Channels are safer for concurrent access, while maps require explicit synchronization using sync.Mutex or sync.Map.

Use error as a return type, and check for errors explicitly:

• GOPATH: Specifies the workspace where Go projects reside.
• GOROOT: Points to the Go installation directory.

Yes, you can format a string without printing it by using string formatting methods and storing the result in a variable. Here are some ways to do it in Python:

Example 1: Using f-strings

name = "Alice"
formatted_string = f"Hello, {name}!"

Example 2: Using .format()

name = "Alice"
formatted_string = "Hello, {}!".format(name)

Example 3: Using % Formatting

name = "Alice"
formatted_string = "Hello, %s!" % name