Golang Interview Questions and Answers for 2026

The act of changing a value's type is known as "type casting" in the Go programming language. To cast a value to a different type in Go, you use the following syntax: 

newType(expression) 

Here is an example of type casting in Go: 

package main 
import "fmt" 
func main() { 
   var x float64 = 3.14 
   var y int = int(x) 
   fmt.Println(y)  // prints "3" 
} 

In this example, the value of x is cast from a float64 to an int. The result is the integer value 3. 

One of the most frequently posed Golang interview questions for experienced, be ready for it. The blank identifier is a unique identifier in the Go programming language that serves as a stand-in for when a value must be thrown away. The blank identifier is represented by an underscore character (_). It has no name and cannot be used as a variable. 

Here is an example of using the blank identifier in Go: 

package main 
import "fmt" 
func main() { 
   // discard the error value 
   _, err := os.Open("filename.txt") 
   if err != nil { 
  panic(err) 
   } 
} 

In this example, the blank identifier is used to discard the value returned by os.Open, which is the file and an error. The error value is assigned to the err variable, while the file value is discarded using the blank identifier. 

Pointers in Go are variables that hold the memory address of other variables. Pointers are useful for passing variables by reference and for modifying variables through indirection. To create a pointer to a struct in Go, you use the & operator to get the memory address of the struct, and you use the * operator to define the type of the pointer: 

package main 

type Person struct { 
   Name string 
   Age  int 
} 
func main() { 
   // create a pointer to a Person struct 
   p := &Person{Name: "John", Age: 30} 
   // modify the struct through the pointer 
   p.Age = 31 
   fmt.Println(p)  // prints "&{John 31}" 
} 

In this example, the p variable is a pointer to a Person struct. The struct is modified through the pointer by assigning a new value to the Age field. 

In the Go programming language, you can embed a struct inside another struct to create a composite data type. This is known as struct embedding.

To embed a struct, you simply specify the struct type as a field in the outer struct. The fields of the inner struct become fields of the outer struct, and the methods of the inner struct become methods of the outer struct.

In Go, a function closure is a function that refers to variables from the scope in which it was defined. These variables are "closed over" by the function, and they remain accessible even after the function is invoked outside of their original scope. 

Here's an example of how to create and use a function closure in Go: 

package main 
import "fmt" 
func main() { 
// Create a variable x and initialize it to 10 
x := 10 
// Create a function closure that captures the value of x 
addX := func(y int) int { 
    return x + y 
} 
// Use the function closure to add x to different values of y 
fmt.Println(addX(5))  // prints 15 
fmt.Println(addX(10)) // prints 20 
// Modify the value of x and see that the function closure still uses the original value 
x = 20 
fmt.Println(addX(5))  // still prints 15 
} 

An anonymous function is a function literal in Go, which is defined and called without a name. They can be assigned to a variable or passed as an argument to another function. Here's an example of how to create and use a function literal in Go:  

package main 
import "fmt" 
func main() { 
// create a function literal that takes two integers as input and returns their sum 
add := func(x, y int) int { 
    return x + y 
} 
// use the function literal to add two numbers 
result := add(5, 10) 
fmt.Println(result) // prints 15 
// pass a function literal as an argument to another function 
someFunc(func(x int) int { 
    return x * x 
}) 
}
func someFunc(f func(int) int) { 
fmt.Println(f(5)) 
} 

In Go, the "select" statement is used to choose between multiple communication operations. It's similar to a "switch" statement, but it's used specifically for communication operations such as sending or receiving data on channels. The select statement blocks until one of its cases can run, then it runs that case, it's a blocking operation.

In Go, a type assertion is used to check if an interface variable contains a specific type and, if it does, to extract the underlying value of that type. 

Here's an example of how to create and use a type assertion in Go: 

package main 
import ( 
"fmt" 
) 
 
func main() { 
// define an interface variable 
var myvar interface{} = "hello" 
 
// use type assertion to check the type of myvar 
str, ok := myvar.(string) 
if ok { 
    fmt.Println(str) 
} else { 
    fmt.Println("myvar is not a string") 
} 
} 

In Go, a type switch is used to check the type of an interface variable and to execute different code based on the type of the underlying value. A type switch is similar to a type assertion, but it can check for multiple types at once, and it doesn't require a variable to hold the underlying value. 

Here's an example of how to create and use a type switch in Go: 

package main 
import ( 
"fmt" 
) 
func doSomething(i interface{}) { 
switch v := i.(type) { 
case int: 
    fmt.Println("i is an int:", v) 
case float64: 
    fmt.Println("i is a float64:", v) 
case string: 
    fmt.Println("i is a string:", v) 
default: 
    fmt.Println("i is of an unknown type") 
} 
} 
func main() { 
doSomething(1) 
doSomething(3.14) 
doSomething("hello") 
doSomething([]int{}) 
} 

One way to change the type of a value in Go is to apply a type conversion. Go has built-in type conversions for most of the basic types. Here is an example for how to create and use a type conversion in Go: 

package main 
import ( 
"fmt" 
) 
func main() { 
var x float64 = 3.14 
var y int = int(x) // type conversion from float64 to int 
fmt.Println(y) // prints "3" 
var a string = "42" 
var b int64 
b, _ = strconv.ParseInt(a, 10, 64) // type conversion from string to int64 using the standard library 
fmt.Println(b) // prints "42" 
} 

The "sync" package in Go provides various types and functions for synchronizing access to shared data. One of the most popular options is sync.Mutex, which ensures that only one goroutine at a time can access the shared data by means of mutual exclusion.

The "sync/atomic" package in Go provides low-level atomic memory operations, such as atomic memory reads and writes, for use with the sync package. These operations allow you to perform atomic read-modify-write operations on variables that are shared across multiple goroutines, without the need for explicit locks or other synchronization.

The "context" package in Go provides a way to carry around request-scoped values and cancelation signals across API boundaries. It is often used in conjunction with http request handlers to provide request-scoped data such as request metadata, request timeout, etc.

The "net/http" package in Go provides a set of functions and types for building HTTP servers and clients. An easy HTTP server built with this software is demonstrated below. 

package main 
import ( 
"fmt" 
"net/http" 
) 
func handler(w http.ResponseWriter, r *http.Request) { 
fmt.Fprint(w, "Hello, World!") 
} 
func main() { 
http.HandleFunc("/", handler) 
http.ListenAndServe(":8080", nil) 
} 

This code creates an HTTP server that listens on port 8080 and handles incoming requests by calling the handler function.

The encoding/json package in Go provides functionality for encoding and decoding JSON data.

To parse JSON data, you can use the json.Unmarshal() function. This function takes a byte slice of JSON data and a pointer to a struct, and it populates the struct with the data from the JSON.

The "math" package in Go provides a set of functions and constants for performing basic mathematical operations, such as trigonometry, exponentials, and logarithms. The "math/rand" package, on the other hand, provides a pseudo-random number generator. 

Here are the general steps for using the "math" and "math/rand" packages to perform mathematical and statistical operations in Go: 

• Import the "math" and "math/rand" packages: To use the "math" and "math/rand" packages, you first need to import them in your code. You can do this by adding the following lines at the top of your file: 

import "math/rand" 

• Use mathematical functions: The "math" package provides a wide range of mathematical functions that you can use, such as Sine, Cosine, Tangent, square root, etc. These functions can be called directly and take a float64 as an argument and return a float64. 
• Seed the random number generator: The "math/rand" package provides a pseudo-random number generator, which uses a seed value to generate random numbers. To seed the generator, you can use the "rand.Seed" function, which takes an int64 value as its argument. 
• Generate random numbers: Once the random number generator is seeded, you can use the "rand.Intn" function to generate a random integer between 0 and a specified upper bound. You can also use the "rand.Float64" function to generate a random float64 value between 0 and 1. 
• Statistical operations: The "math" package also provides statistical operation like average, variance, etc, you can use these functions on slices of float64 
• Handle errors: Be aware that some of the functions in the math package might return errors depending on the inputs, like log(-1) will return an error. 

The "crypto" package in Go provides a set of functions and types for performing various cryptographic operations, such as message digests, digital signatures, and encryption. Here's some example code that shows how you might use the "crypto" package to perform cryptographic operations in Go: 

package main 
import ( 
    "crypto/sha256" 
    "fmt" 
) 
func main() { 
    // Create a new SHA-256 hash 
    hash := sha256.New() 
    // Write data to the hash 
    hash.Write([]byte("hello world")) 
    // Get the resulting hash value 
    hashValue := hash.Sum(nil) 
    // Print the hash value 
    fmt.Printf("Hash: %x\n", hashValue) 
} 

It's no surprise that this one pops up often in senior Golang interview questions. The "os" package in Go provides a set of functions and types for interacting with the operating system, such as working with files and directories, running external commands, and accessing environment variables. 

Here are the general steps for using the "os" package to interact with the operating system in Go: 

• Import the "os" package: To use the "os" package, you first need to import it in your code. You can do this by adding the following line at the top of your file: import "os" 
• You can access environment variables using the "os.Getenv" function, which takes a string representing the name of the environment variable and returns a string representing the value of the environment variable. value := os.Getenv("MY_VARIABLE") 
• Run external commands: You can run external commands using the "os.Command" function which can be called with the command name and arguments, then run it.  

cmd := exec.Command("ls", "-l")  
output, err := cmd.Output() 

• Create and delete files and directories: You can create, delete, and move files and directories using the "os.Create", "os.Remove" and "os.Rename" functions. os.Create("newfile.txt")  

os.Remove("existingfile.txt")  
os.Rename("oldname.txt", "newname.txt") 

• For modifying file properties, the "os" package includes commands like "chmod" and "chtimes", among others. 
• If something goes wrong at any stage—for example, the command isn't executed successfully, the file isn't deleted, etc.—you'll need to deal with it. 

The "bufio" package in Go provides buffered I/O for reading and writing streams of bytes. 

To read information from a file, you can use the "bufio" package, as demonstrated here: 

package main 
import ( 
"bufio" 
"fmt" 
"os" 
) 
func main() { 
file, err := os.Open("file.txt") 
if err != nil { 
    fmt.Println(err) 
    return 
} 
defer file.Close() 
scanner := bufio.NewScanner(file) 
for scanner.Scan() { 
    fmt.Println(scanner.Text()) 
} 
if err := scanner.Err(); err != nil { 
    fmt.Println(err) 
} 
} 

This example uses the os.Open function to open a file called "file.txt" for reading. It then creates a new bufio.Scanner and sets the input source to the file by passing it as the argument to the NewScanner function. The Scan method of the scanner is used in a loop to read the file line by line. The Text method of the scanner is used to return the current line as a string. 

The strings package in Go provides a variety of functions for manipulating strings. Below are a few examples of how you can use the strings package to manipulate strings in Go: 

Contains(s, substr string) bool: returns true if the string s contains the substring substr. 
package main 
import ( 
"fmt" 
"strings" 
) 
func main() { 
s := "Hello, World!" 
substr := "World" 
fmt.Println(strings.Contains(s, substr))  // true 
} 
Count(s, sep string) int: returns the number of non-overlapping instances of sep in s. 
package main 
import ( 
"fmt" 
"strings" 
) 
func main() { 
s := "Hello, World! How are you?" 
sep := " " 
fmt.Println(strings.Count(s, sep))  // 6 
} 

The bytes package in Go provides a variety of functions for manipulating byte slices. Below is an example of how you can use the bytes package to manipulate byte slices in Go: 

Compare(a, b []byte) int: compares two byte slices lexicographically and returns an integer indicating their order (-1, 0, or 1) 

package main 
import ( 
"fmt" 
"bytes" 
) 
func main() { 
a := []byte("hello") 
b := []byte("world") 
fmt.Println(bytes.Compare(a, b)) // -1 
} 

The encoding/binary package in Go provides functions for encoding and decoding data in binary format. Below is an example to encoding/binary package to encode and decode binary data in Go: 

Encoding an int32 value to a byte slice using the Write function: 

package main 
import ( 
"bytes" 
"encoding/binary" 
"fmt" 
) 
func main() { 
var num int32 = 12345 
buf := new(bytes.Buffer) 
err := binary.Write(buf, binary.LittleEndian, num) 
if err != nil { 
    fmt.Println("binary.Write failed:", err) 
} 
fmt.Printf("% x", buf.Bytes()) // 39 30 00 00 
} 

The Write function takes three arguments: the first is the buffer to write to, the second is the byte order, and the third is the value to be encoded. In this case, we are using binary.LittleEndian for the byte order, and num for the value to be encoded. 

The compress/gzip package in Go provides functions for compressing and decompressing data using the gzip algorithm. Below is an example to compress/gzip package to compress and decompress data using the gzip algorithm in Go: 

package main 
import ( 
"bytes" 
"compress/gzip" 
"fmt" 
"io" 
"log" 
) 
func main() { 
// Data to be compressed 
data := []byte("Hello World") 
// Compress the data 
var b bytes.Buffer 
w := gzip.NewWriter(&b) 
if _, err := w.Write(data); err != nil { 
    log.Fatalln(err) 
} 
if err := w.Close(); err != nil { 
    log.Fatalln(err) 
}  
// Decompress the data 
r, err := gzip.NewReader(&b) 
if err != nil { 
    log.Fatalln(err) 
} 
defer r.Close() 
var result bytes.Buffer 
io.Copy(&result, r) 
fmt.Println(result.String()) // Hello World 
} 

The database/sql package in Go provides a simple and clean interface for interacting with SQL databases. An example of how you might use it to perform a simple query to select all rows from a table called "users":

package main 
import ( 
    "database/sql" 
    "fmt"
    _ "github.com/go-sql-driver/mysql" // Required import for MySQL driver 
) 
func main() { 
    // Open a connection to the database 
    db, err := sql.Open("mysql", "user:password@tcp(host:port)/dbname") 
    if err != nil { 
    fmt.Println(err) 
    return 
    } 
    defer db.Close() 
    // Prepare a statement to select all rows from the users table 
    rows, err := db.Query("SELECT * FROM users") 
    if err != nil { 
    fmt.Println(err) 
    return 
    } 
    defer rows.Close() 
    // Iterate over the rows and print the results 
    for rows.Next() { 
    var id int 
    var name string 
    var age int 
    err := rows.Scan(&id, &name, &age) 
    if err != nil { 
    fmt.Println(err) 
    return 
    } 
    fmt.Println(id, name, age) 
    } 
} 

In this example, we import the database/sql package, as well as the MySQL driver for database/sql, which is available as a separate package (github.com/go-sql-driver/mysql). We then use the sql.Open() function to open a connection to the database, passing in the driver name ("mysql") and the data source name (DSN) in the format "user:password@tcp(host:port)/dbname". 

The html/template package in Go provides a set of functions for working with HTML templates. You can use this package to parse a template file and then execute it with data to produce the final HTML output. Here's an example of how to use the package to generate an HTML template:

package main 
import ( 
"html/template" 
"os" 
) 
type Person struct { 
Name string 
Age  int 
} 
func main() { 
// define the template 
tmpl := ` 
<h1>{{.Name}}</h1> 
<p>Age: {{.Age}}</p>  
// create a new template 
t, err := template.New("person").Parse(tmpl) 
if err != nil { 
    panic(err) 
} 
// create a Person struct 
p := Person{Name: "Alice", Age: 30} 
// execute the template and write the result to os.Stdout 
err = t.Execute(os.Stdout, p) 
if err != nil { 
    panic(err) 
} 
} 

This code defines a struct type called Person with two fields, Name and Age. It then creates an HTML template string that uses Go's template language to insert the Name and Age values of a Person struct into the HTML. It creates a new template object by calling template.New("person") and parsing the template string with Parse(tmpl).

Then creates an instance of Person, then using the Execute function, pass it the struct to fill the data of the template.