Default case in select in Go - Mini Project: Build & Apply

Default Case in Select

📖 Scenario: Imagine you are building a simple Go program that listens to two channels for messages. Sometimes, no messages arrive, and you want to handle that situation gracefully without blocking your program.

🎯 Goal: You will create a Go program that uses a select statement with a default case. This default case will run when no channels are ready, allowing the program to continue working without waiting.

📋 What You'll Learn

Create two channels named chan1 and chan2.

Create a select statement that listens to both channels.

Add a default case in the select to handle when no channels have data.

Print messages to show which case ran.

💡 Why This Matters

🌍 Real World

Channels and select statements are used in Go programs to handle multiple tasks at the same time, like waiting for user input, network messages, or timers.

💼 Career

Understanding how to use <code>select</code> with a <code>default</code> case is important for writing efficient and responsive Go programs, a skill valued in backend development and systems programming.

1

Create two channels

Create two channels called chan1 and chan2 that can send and receive strings.

Go

// Your code here

Hint

Use make(chan string) to create each channel.

2

Add a select statement with default case

Add a select statement inside main that listens to chan1 and chan2. Add a default case that prints "No messages received".

Go

package main

func main() {
    chan1 := make(chan string)
    chan2 := make(chan string)

    // Add select statement with default case here
}

Hint

Use select with case for each channel and a default case for no messages.

3

Send a message to chan1

Before the select statement, start a new goroutine that sends the string "hello" to chan1.

Go

package main

import "fmt"

func main() {
    chan1 := make(chan string)
    chan2 := make(chan string)

    // Start a goroutine to send "hello" to chan1

    select {
    case msg1 := <-chan1:
        fmt.Println("Received from chan1:", msg1)
    case msg2 := <-chan2:
        fmt.Println("Received from chan2:", msg2)
    default:
        fmt.Println("No messages received")
    }
}

Hint

Use a goroutine with go func() { chan1 <- "hello" }() to send the message.

4

Print the result

Run the program and print the output. The program should print Received from chan1: hello.

Go

package main

import "fmt"

func main() {
    chan1 := make(chan string)
    chan2 := make(chan string)

    go func() {
        chan1 <- "hello"
    }()

    select {
    case msg1 := <-chan1:
        fmt.Println("Received from chan1:", msg1)
    case msg2 := <-chan2:
        fmt.Println("Received from chan2:", msg2)
    default:
        fmt.Println("No messages received")
    }
}

// Run the program to see the output

Hint

Run the program. It should print Received from chan1: hello.

Practice

1.

What does the default case do in a Go select statement?

easy

A. Closes all channels automatically

B. Blocks until a channel is ready

C. Runs immediately if no other channel operations are ready

D. Sends data to all channels simultaneously

Solution

1. Step 1: Understand the role of select

   The select statement waits on multiple channel operations.

2. Step 2: Identify the purpose of default

   The default case runs immediately if no channels are ready, preventing blocking.

3. Final Answer:

   Runs immediately if no other channel operations are ready -> Option C

4. Quick Check:

   default runs when no channels ready = A [OK]

Hint: Default runs instantly if no channels are ready [OK]

Common Mistakes:

• Thinking default blocks until a channel is ready
• Assuming default closes channels
• Believing default sends data to all channels

2.

Which of the following is the correct syntax for using a default case in a Go select?

select {
  case msg := <-ch1:
    fmt.Println(msg)
  // What goes here?
}

easy

A. default:
fmt.Println("No message received")

B. else:
fmt.Println("No message received")

C. fallback:
fmt.Println("No message received")

D. otherwise:
fmt.Println("No message received")

Solution

1. Step 1: Recall Go select syntax

   The default keyword is used for the fallback case in select.

2. Step 2: Match correct keyword

   Only default is valid; else, fallback, and otherwise are invalid in Go select.

3. Final Answer:

   default: fmt.Println("No message received") -> Option A

4. Quick Check:

   Use default keyword in select = C [OK]

Hint: Default is the only valid fallback keyword in select [OK]

Common Mistakes:

• Using else instead of default
• Trying fallback or otherwise keywords
• Omitting the colon after default

3.

What will be the output of this Go program?

package main
import (
  "fmt"
  "time"
)
func main() {
  ch := make(chan string)
  select {
  case msg := <-ch:
    fmt.Println(msg)
  default:
    fmt.Println("No message received")
  }
}

medium

A. Compilation error

B. Program blocks forever

C. Empty string printed

D. No message received

Solution

1. Step 1: Analyze channel state

   The channel ch is created but no data is sent, so it's empty and no receive is ready.

2. Step 2: Understand select with default

   Since no data is ready on ch, the default case runs immediately, printing "No message received".

3. Final Answer:

   No message received -> Option D

4. Quick Check:

   No data ready triggers default = A [OK]

Hint: Default runs if channel has no data ready [OK]

Common Mistakes:

• Expecting program to block waiting for channel
• Thinking empty string is printed
• Assuming compilation error due to empty channel

4.

Identify the error in this Go code snippet using select with a default case:

select {
case msg := <-ch:
  fmt.Println(msg)
default
  fmt.Println("No message")
}

medium

A. Default case must be last

B. Missing colon after default keyword

C. Cannot use variable msg in select

D. Channel ch is not initialized

Solution

1. Step 1: Check default syntax

   The default case requires a colon (:) after the keyword.

2. Step 2: Identify missing colon

   The code has default without a colon, causing a syntax error.

3. Final Answer:

   Missing colon after default keyword -> Option B

4. Quick Check:

   Default needs colon (:) = D [OK]

Hint: Always put colon after default in select [OK]

Common Mistakes:

• Forgetting colon after default
• Assuming default must be last case
• Confusing variable scope in select

5.

Consider this Go program snippet:

ch1 := make(chan int)
ch2 := make(chan int)
go func() {
  time.Sleep(100 * time.Millisecond)
  ch1 <- 1
}()
go func() {
  time.Sleep(200 * time.Millisecond)
  ch2 <- 2
}()
select {
case val := <-ch1:
  fmt.Println("Received from ch1:", val)
case val := <-ch2:
  fmt.Println("Received from ch2:", val)
default:
  fmt.Println("No channels ready")
}

What is the most likely output when this select runs?

hard

A. No channels ready

B. Received from ch1: 1

C. Received from ch2: 2

D. Program deadlocks

Solution

1. Step 1: Understand goroutine timing

   The goroutines send to channels after 100ms and 200ms delays, but the select runs immediately.

2. Step 2: Check channel readiness at select

   At the moment select runs, neither channel has data ready, so no case is ready.

3. Step 3: Default case triggers

   Because no channels are ready, the default case runs, printing "No channels ready".

4. Final Answer:

   No channels ready -> Option A

5. Quick Check:

   Default runs if no channel ready = B [OK]

Hint: Select runs immediately; default if no channel ready [OK]

Common Mistakes:

• Assuming select waits for channels
• Expecting output from ch1 or ch2 immediately
• Thinking program deadlocks without default