Default case in select in Go - Step-by-Step Execution

Concept Flow - Default case in select

Start select

↓

Check channels ready?

No→Default case runs

Yes↓

Run ready channel case

↓

End select

The select statement checks if any channel is ready. If none are ready, it runs the default case immediately.

Execution Sample

Go

select {
case msg := <-ch1:
    fmt.Println("Received", msg)
default:
    fmt.Println("No message received")
}

This code tries to receive from channel ch1. If no message is ready, it runs the default case.

Execution Table

Step	Channel ch1 ready?	Action	Output
1	No	Run default case	No message received
2	Yes	Receive from ch1	Received <message>

💡 Select ends after running one case: either default if no channels ready, or a ready channel case.

Variable Tracker

Variable	Start	After Step 1	After Step 2
msg	undefined	undefined	<message from ch1>

Key Moments - 2 Insights

Why does the default case run immediately even if no message is sent on ch1?

Because select checks if any channel is ready. If none are ready, it runs the default case right away, as shown in execution_table step 1.

What happens if the default case is removed and no channels are ready?

The select blocks (waits) until a channel becomes ready. This is different from running default immediately, as no default means no immediate fallback.

Visual Quiz - 3 Questions

Look at the execution table, what happens at step 1 when ch1 is not ready?

A The default case runs immediately

B The program waits for ch1

C The program crashes

D The select statement skips

💡 Hint

See execution_table row 1 where channel ch1 is not ready and default runs.

At which step does the variable 'msg' get a value?

A Step 1

B Step 2

C Before select

D Never

💡 Hint

Check variable_tracker row for 'msg' showing value assigned after step 2.

If we remove the default case, what changes in the execution?

A Select runs default anyway

B Select runs no cases and exits

C Select blocks until a channel is ready

D Select runs all cases

💡 Hint

Refer to key_moments explanation about behavior without default case.

Concept Snapshot

select {
case <-ch1:
    // runs if ch1 ready
default:
    // runs if no channels ready immediately
}

Default case prevents blocking by running instantly if no channel is ready.

Full Transcript

The select statement in Go checks multiple channels to see if any are ready to communicate. If a channel is ready, its case runs. If no channels are ready and a default case exists, the default case runs immediately without waiting. This prevents the program from blocking. If there is no default case and no channels are ready, the select statement waits (blocks) until a channel becomes ready. Variables like 'msg' get assigned only when their channel case runs. The execution table shows these steps clearly: when ch1 is not ready, default runs; when ch1 is ready, the message is received. This helps beginners understand how select with default avoids waiting and handles no-ready channels gracefully.

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