Empty interface in Go - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the empty interface in Go?

The empty interface in Go is written as interface{}. It can hold values of any type because every type implements at least zero methods.

beginner

How do you declare a variable that can hold any type using the empty interface?

You declare it like this: var x interface{}. Then you can assign any value to x, like a string, int, or struct.

intermediate

Why is the empty interface useful in Go?

It is useful because it allows functions or data structures to accept or store any type of value, making code flexible and generic.

intermediate

How do you retrieve the original type from an empty interface variable?

You use type assertion, for example: value, ok := x.(int) checks if x holds an int and extracts it safely.

intermediate

Can the empty interface be used to create a slice that holds different types?

Yes! For example, var list []interface{} can hold ints, strings, structs, etc., all in the same slice.

What does interface{} represent in Go?

A An interface that accepts only strings

B An interface with one method

C An interface that accepts any type

D An interface that accepts only integers

The empty interface interface{} can hold any type because all types implement zero methods.

How do you declare a variable that can hold any type in Go?

A var x interface{}

B var x int

C var x string

D var x any

The empty interface interface{} is used to declare variables that can hold any type.

Which Go feature allows you to check the actual type stored in an empty interface variable?

A Type declaration

B Type embedding

C Type conversion

D Type assertion

Type assertion lets you extract the concrete value and check its type from an empty interface.

Can a slice of type []interface{} hold different types of values?

A No, only one type allowed

B Yes, it can hold any types

C Only integers

D Only strings

A slice of empty interfaces can hold values of any type, making it flexible.

What happens if you try a wrong type assertion on an empty interface variable?

A It causes a runtime panic if unchecked

B It automatically converts the type

C It returns zero value silently

D It compiles but ignores the assertion

A wrong type assertion without checking causes a runtime panic. Use the two-value form to avoid this.

Explain what the empty interface is in Go and why it is useful.

Think about how Go treats types and interfaces.

Describe how to safely extract a value from an empty interface variable.

Remember the form: value, ok := x.(Type)

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{}