Empty interface in Go - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a variable that can hold any type using the empty interface.

Go

var data [1]

Drag options to blanks, or click blank then click option'

Aint

Binterface{}

Cstring

Dstruct{}

Attempts:

3 left

💡 Hint

Common Mistakes

Using a concrete type like int or string instead of the empty interface.

Using struct{} which is an empty struct, not an interface.

The empty interface interface{} in Go can hold values of any type.

2fill in blank

medium

Complete the code to assign a string value to an empty interface variable.

Go

var value interface{}
value = [1]

Drag options to blanks, or click blank then click option'

A"hello"

B100

Ctrue

Dnil

Attempts:

3 left

💡 Hint

Common Mistakes

Assigning a number or boolean when a string is expected.

Forgetting to use quotes around the string.

You can assign any value to an empty interface variable. Here, a string literal must be in quotes.

3fill in blank

hard

Fix the error in the code by completing the type assertion from an empty interface to int.

Go

var data interface{} = 42
num := data.[1]

Drag options to blanks, or click blank then click option'

A(int)

Bcast

Ctype

Dassert

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'cast' or 'type' which are not Go keywords for this.

Trying to use slice notation like ([]int).

In Go, to get the concrete value from an interface, you use a type assertion: data.(int).

4fill in blank

hard

Fill both blanks to create a map from string to empty interface and assign a value.

Go

data := map[string][1]{
	"key": [2],
}

Drag options to blanks, or click blank then click option'

Ainterface{}

B"value"

Cint

Dnil

Attempts:

3 left

💡 Hint

Common Mistakes

Using int as the map value type when it should be interface{}.

Assigning a string value without quotes.

The map value type is the empty interface interface{} to hold any type. The value assigned is a string literal.

5fill in blank

hard

Fill all three blanks to create a slice of empty interfaces and append a boolean value.

Go

var items [][1]
items = append(items, [2])
fmt.Println(items[[3]])

Drag options to blanks, or click blank then click option'

Ainterface{}

Btrue

C0

Dfalse

Attempts:

3 left

💡 Hint

Common Mistakes

Using false instead of true for the appended value.

Using 1 instead of 0 for the slice index.

The slice holds empty interfaces. We append a boolean true. The first element is at index 0.

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