Best practices in Go - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Go code snippet?

Consider the following Go program that uses channels. What will it print?

Go

package main

import (
	"fmt"
)

func main() {
	ch := make(chan int, 2)
	ch <- 1
	ch <- 2
	close(ch)

	for v := range ch {
		fmt.Print(v)
	}
}

A 12

B 21

C runtime error: send on closed channel

D 12 followed by deadlock

💡 Hint

Remember that closing a channel allows range to receive remaining buffered values.

The channel is buffered with capacity 2. It receives 1 and 2, then closes. The range loop reads all values until the channel is empty, printing "12".

🧠 Conceptual

intermediate

Which is the best practice for error handling in Go?

In Go, what is the recommended way to handle errors returned by functions?

A Return error values and check them explicitly after function calls

B Use panic() for all errors to stop execution immediately

C Ignore errors if they are not critical

D Use exceptions and try-catch blocks like in other languages

💡 Hint

Think about Go's philosophy of explicit error handling.

Go encourages returning error values and checking them explicitly to handle errors gracefully and clearly.

🔧 Debug

advanced

What error does this Go code produce?

Analyze the following Go code snippet. What error will it cause when compiled?

Go

package main

func main() {
	var x int
	if x := 5; x > 3 {
		println(x)
	}
	println(x)
}

A Compilation error: x redeclared in the same block

B Prints 5 then 0

C Prints 0 then 5

D Runtime panic: variable x used before initialization

💡 Hint

Consider variable shadowing and scopes in Go.

The 'x' inside the if statement shadows the outer 'x'. Inside the if block, x is 5 and prints 5. Outside, the original x is 0 and prints 0.

🔧 Debug

advanced

Which option causes a runtime panic in Go?

Which of the following Go code snippets will cause a runtime panic when executed?

Go

package main

func main() {
	var x int
	if x := 5; x > 3 {
		println(x)
	}
	println(x)
}

A

m := map[string]int{"a": 1}
 m["b"] = 2

B

var m map[string]int = map[string]int{"a": 1, "b": 2}
 m["c"] = 3

C

m := make(map[string]int)
 m["a"] = 1

D

var m map[string]int
 m["a"] = 1

💡 Hint

Remember that maps must be initialized with make() or a map literal before you can assign to them.

Option D declares a nil map (var m map[string]int) and tries to assign m["a"] = 1, which causes a runtime panic: 'assignment to entry in nil map'. Options B, C, and D all properly initialize the map before assignment.

🚀 Application

expert

How many goroutines are running after this Go program executes?

Consider this Go program. How many goroutines are alive after the main function finishes?

Go

package main

import (
	"fmt"
	"time"
)

func worker(done chan bool) {
	time.Sleep(100 * time.Millisecond)
	done <- true
}

func main() {
	done := make(chan bool)
	for i := 0; i < 3; i++ {
		go worker(done)
	}
	for i := 0; i < 3; i++ {
		<-done
	}
	fmt.Println("All workers done")
}

A 4 goroutines

B 3 goroutines

C 0 goroutines

D 1 goroutine

💡 Hint

Think about when goroutines finish and the main function exits.

The main function waits for all 3 worker goroutines to send done signals before printing. After that, all worker goroutines have finished, so no goroutines remain alive.

Practice

1. Which of the following is a best practice when naming variables in Go?

easy

A. Use clear and descriptive names that explain the variable's purpose

B. Use single letters for all variable names to save space

C. Use names with special characters to make them unique

D. Use very long names with unnecessary details

Solution

1. Step 1: Understand variable naming importance

   Clear and descriptive names help others understand what the variable holds.

2. Step 2: Evaluate each option

   Using single letters or special characters makes code confusing. Very long names are hard to read.

3. Final Answer:

   Use clear and descriptive names that explain the variable's purpose -> Option A

4. Quick Check:

   Clear names improve readability [OK]

Hint: Pick option promoting clarity and readability [OK]

Common Mistakes:

• Choosing short, unclear variable names
• Using special characters in names
• Making names unnecessarily long

2. Which of the following Go code snippets correctly handles an error returned by a function?

easy

A. result, err := doSomething()
if err = nil {
fmt.Println("Error occurred")
}

B. result, err := doSomething()
if err == nil {
fmt.Println("Error occurred")
}

C. result, err := doSomething()
if err != nil {
fmt.Println("Error occurred")
}

D. result, _ := doSomething()
fmt.Println(result)

Solution

1. Step 1: Identify correct error check syntax

   In Go, errors are checked with 'if err != nil' to detect an error.

2. Step 2: Check each option's error handling

   result, err := doSomething() if err != nil { fmt.Println("Error occurred") } prints an error message when err is not nil, which is correct. result, err := doSomething() if err == nil { fmt.Println("Error occurred") } checks err == nil incorrectly. result, err := doSomething() if err = nil { fmt.Println("Error occurred") } uses assignment '=' instead of comparison '=='. result, _ := doSomething() fmt.Println(result) ignores the error by using _ and prints the result anyway, which is incorrect.

3. Final Answer:

   result, err := doSomething() if err != nil { fmt.Println("Error occurred") } -> Option C

4. Quick Check:

   Check error with 'err != nil' [OK]

Hint: Remember: error check is 'if err != nil' [OK]

Common Mistakes:

• Using '=' instead of '==' in conditions
• Checking 'err == nil' to detect errors
• Ignoring errors without handling

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

package main
import "fmt"
func main() {
    nums := []int{1, 2, 3}
    sum := 0
    for _, n := range nums {
        sum += n
    }
    fmt.Println(sum)
}

medium

A. 6

B. 123

C. 0

D. Error

Solution

1. Step 1: Understand the loop and sum calculation

   The loop goes through each number in nums: 1, 2, 3 and adds them to sum.

2. Step 2: Calculate the sum

   sum = 0 + 1 + 2 + 3 = 6

3. Final Answer:

   6 -> Option A

4. Quick Check:

   Sum of [1,2,3] = 6 [OK]

Hint: Sum elements by adding each in the loop [OK]

Common Mistakes:

• Concatenating numbers as strings
• Starting sum from wrong initial value
• Misunderstanding range loop syntax

4. Identify the error in the following Go code snippet and choose the best fix:

func divide(a, b int) int {
    return a / b
}

func main() {
    result := divide(10, 0)
    fmt.Println(result)
}

medium

A. Change function to return float64 instead of int

B. Add error handling to check if b is zero before dividing

C. Remove the divide function and do division inline

D. Ignore the error since Go handles division by zero automatically

Solution

1. Step 1: Identify the problem with division by zero

   Dividing by zero causes a runtime panic in Go, which must be prevented.

2. Step 2: Choose the fix that prevents panic

   Adding error handling to check if b is zero before dividing avoids the panic. Changing return type or removing function does not fix the error. Go does not handle division by zero automatically.

3. Final Answer:

   Add error handling to check if b is zero before dividing -> Option B

4. Quick Check:

   Prevent division by zero [OK]

Hint: Always check divisor before dividing to avoid panic [OK]

Common Mistakes:

• Ignoring division by zero errors
• Assuming Go handles zero division safely
• Changing return type without fixing logic

5. You want to write a Go function that returns a map of words to their counts from a slice of strings. Which approach follows best practices for clarity, error handling, and simplicity?

hard

A. Use nested loops to count words multiple times for accuracy

B. Use global variables to store counts and update them inside the function

C. Return a pointer to the map and panic if input slice is empty

D. Use a simple loop to count words, return the map, and handle empty input gracefully

Solution

1. Step 1: Understand best practices for function design

   Functions should be simple, clear, and handle edge cases like empty input without panicking.

2. Step 2: Evaluate each option

   Use a simple loop to count words, return the map, and handle empty input gracefully uses a simple loop and handles empty input gracefully, which is best practice. Use nested loops to count words multiple times for accuracy is inefficient with nested loops. Return a pointer to the map and panic if input slice is empty uses panic and pointers unnecessarily. Use global variables to store counts and update them inside the function uses global variables, which reduces clarity and safety.

3. Final Answer:

   Use a simple loop to count words, return the map, and handle empty input gracefully -> Option D

4. Quick Check:

   Simple, clear, safe function [OK]

Hint: Keep functions simple and handle edge cases safely [OK]

Common Mistakes:

• Using complex nested loops unnecessarily
• Panicking instead of returning errors
• Using global variables inside functions