Empty interface in Go - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of assigning different types to empty interface

What is the output of this Go program?

Go

package main
import "fmt"
func main() {
    var x interface{}
    x = 42
    fmt.Printf("%T %v\n", x, x)
    x = "hello"
    fmt.Printf("%T %v\n", x, x)
}

A

interface {} 42
interface {} hello

B Compilation error

C

42
hello

D

int 42
string hello

💡 Hint

Empty interface can hold any type, and %T prints the dynamic type.

The empty interface can hold any value. When printing with %T, it shows the actual type stored, so first int then string.

🧠 Conceptual

intermediate

Understanding empty interface usage

Which statement about the empty interface in Go is TRUE?

A It can hold values of any type.

B It can only hold values of type interface{}.

C It requires explicit type conversion to assign values.

D It cannot be used as a function parameter.

💡 Hint

Think about what 'empty interface' means in Go.

The empty interface has zero methods, so all types implement it and can be assigned to it.

❓ Predict Output

advanced

Output of type assertion with empty interface

What is the output of this Go program?

Go

package main
import "fmt"
func main() {
    var x interface{} = 3.14
    v, ok := x.(int)
    fmt.Println(v, ok)
}

A 3 true

B 0 false

C 3.14 true

D Compilation error

💡 Hint

Type assertion fails if the dynamic type does not match.

x holds a float64, but we assert int, so v is zero value 0 and ok is false.

🔧 Debug

advanced

Identify the runtime error with empty interface

What runtime error will this Go program produce?

Go

package main
import "fmt"
func main() {
    var x interface{} = "golang"
    v := x.(int)
    fmt.Println(v)
}

A panic: interface conversion: interface {} is string, not int

B Compilation error: cannot convert string to int

C 0

D golang

💡 Hint

Direct type assertion without checking can cause panic if types mismatch.

The program panics because x holds a string but is asserted as int without checking.

🚀 Application

expert

Number of elements in slice of empty interfaces

What is the length of the slice 'data' after this code runs?

Go

package main
func main() {
    data := []interface{}{1, "two", 3.0, true}
    // What is len(data)?
}

A 3

B 1

C 4

D 0

💡 Hint

Count the number of elements inside the slice literal.

The slice contains four elements of different types, all stored as interface{} values.

Practice

1. What does an empty interface interface{} represent in Go?

easy

A. A type that can hold any value of any type

B. A type that holds only integer values

C. A type that holds only string values

D. A type that cannot hold any value

Solution

1. Step 1: Understand the empty interface definition

   The empty interface interface{} has no methods, so it can hold any type of value.

2. Step 2: Recall Go's type system

   Since all types implement zero or more methods, and the empty interface requires none, all types satisfy it.

3. Final Answer:

   A type that can hold any value of any type -> Option A

4. Quick Check:

   Empty interface = any type [OK]

Hint: Empty interface means it accepts any type of value [OK]

Common Mistakes:

• Thinking it holds only specific types like int or string
• Confusing it with interfaces that have methods
• Assuming it cannot hold values

2. Which of the following is the correct syntax to declare a variable of empty interface type in Go?

easy

A. var x interface{}

B. var x interface

C. var x emptyinterface{}

D. var x interface(void)

Solution

1. Step 1: Recall the syntax for empty interface

   The empty interface is written as interface{} with empty braces.

2. Step 2: Check each option

   Only var x interface{} is valid Go syntax for declaring an empty interface variable.

3. Final Answer:

   var x interface{} -> Option A

4. Quick Check:

   Empty interface syntax = interface{} [OK]

Hint: Empty interface always uses empty braces {} after interface [OK]

Common Mistakes:

• Omitting the braces {}
• Using incorrect keywords like emptyinterface
• Adding invalid parameters inside interface

3. What will be the output of the following Go code?

var val interface{} = 42
fmt.Println(val)

medium

A. interface{}

B. 42

C. Compilation error

D. <nil>

Solution

1. Step 1: Understand variable assignment

   The variable val is declared as empty interface and assigned the integer 42.

2. Step 2: Print the value

   Printing val outputs the stored value, which is 42.

3. Final Answer:

   42 -> Option B

4. Quick Check:

   Empty interface holds 42, prints 42 [OK]

Hint: Empty interface prints stored value directly [OK]

Common Mistakes:

• Expecting the type name instead of value
• Thinking it causes a compile error
• Assuming it prints <nil> when assigned a value

4. Identify the error in the following Go code snippet:

var x interface{}
x = 3.14
fmt.Println(x + 1)

medium

A. No error, prints 4.14

B. Prints <nil>

C. Compile error: invalid operation on interface{}

D. Runtime panic due to type assertion failure

Solution

1. Step 1: Analyze the variable type

   Variable x is of type interface{}, holding a float64 value 3.14.

2. Step 2: Check the operation

   Adding 1 to x is invalid because interface{} does not support arithmetic operations directly.

3. Final Answer:

   Compile error: invalid operation on interface{} -> Option C

4. Quick Check:

   Cannot do math directly on interface{} [OK]

Hint: Cannot do math on interface{} without type assertion [OK]

Common Mistakes:

• Assuming interface{} behaves like the stored type automatically
• Expecting runtime panic instead of compile error
• Ignoring the need for type assertion

5. Given a slice of empty interfaces holding mixed types:

items := []interface{}{42, "hello", 3.14, true}

Which code snippet correctly counts how many elements are of type int?

hard

A. count := 0
for _, v := range items {
if v.Type() == int {
count++
}
}
fmt.Println(count)

B. count := 0
for _, v := range items {
if v == int {
count++
}
}
fmt.Println(count)

C. count := 0
for _, v := range items {
if reflect.TypeOf(v) == "int" {
count++
}
}
fmt.Println(count)

D. count := 0
for _, v := range items {
if _, ok := v.(int); ok {
count++
}
}
fmt.Println(count)

Solution

1. Step 1: Understand type assertion syntax

   To check if an interface{} holds an int, use v.(int) with the comma-ok idiom.

2. Step 2: Evaluate each option

   count := 0 for _, v := range items { if _, ok := v.(int); ok { count++ } } fmt.Println(count) uses correct type assertion and counts ints. The other options use invalid comparisons or incorrect reflection usage.

3. Final Answer:

   count := 0 for _, v := range items { if _, ok := v.(int); ok { count++ } } fmt.Println(count) -> Option D

4. Quick Check:

   Use type assertion with comma-ok to check type [OK]

Hint: Use type assertion with comma-ok to check interface{} type [OK]

Common Mistakes:

• Comparing interface{} directly to a type
• Using reflect.TypeOf(v) == "int" (string instead of type)
• Calling Type() method which does not exist on interface{}